ಫಾಸ್ಟಾಪಿ ಹಿನ್ನೆಲೆ ಕಾರ್ಯವನ್ನು ಸರಿಪಡಿಸುವುದು 502 AWS ಸ್ಥಿತಿಸ್ಥಾಪಕ ಬೀನ್‌ಸ್ಟಾಕ್‌ನಲ್ಲಿ ದೋಷ

ಸ್ಥಿತಿಸ್ಥಾಪಕ ಬೀನ್‌ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಫಾಸ್ಟಾಪಿಯಲ್ಲಿ ಹಿನ್ನೆಲೆ ಕಾರ್ಯಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವುದು

AWS ಸ್ಥಿತಿಸ್ಥಾಪಕ ಬೀನ್‌ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಫಾಸ್ಟಾಪಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸುವುದು ಸುಗಮ ಅನುಭವವಾಗಬಹುದು you ನೀವು 502 ಕೆಟ್ಟ ಗೇಟ್‌ವೇ ದೋಷದಂತಹ ಸಮಸ್ಯೆಗಳಿಗೆ ಸಿಲುಕುವವರೆಗೆ. ಡೆವಲಪರ್‌ಗಳು ಎದುರಿಸುತ್ತಿರುವ ಒಂದು ಸಾಮಾನ್ಯ ನೋವು ಪಾಯಿಂಟ್ ದೀರ್ಘಾವಧಿಯ ಹಿನ್ನೆಲೆ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು, ಇದು ಗೇಟ್‌ವೇ ಕಾಲಾವಧಿಗಳನ್ನು ಪ್ರಚೋದಿಸುತ್ತದೆ. 🚀

ಇದನ್ನು g ಹಿಸಿ: ನೀವು ಎಪಿಐ ಎಂಡ್‌ಪೋಯಿಂಟ್ ಅನ್ನು ಹೊಂದಿದ್ದೀರಿ, ಅದು ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಪಿಡಿಎಫ್ ಫೈಲ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಸುಮಾರು 30 ಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಸ್ಥಳೀಯವಾಗಿ, ಎಲ್ಲವೂ ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಆದರೆ ಸ್ಥಿತಿಸ್ಥಾಪಕ ಬೀನ್‌ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಒಮ್ಮೆ ನಿಯೋಜಿಸಿದ ನಂತರ, ಎಪಿಐ ಕರೆ ನಿರಾಶಾದಾಯಕ 502 ದೋಷದಿಂದ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. ನೀವು nginx ಮತ್ತು ಗುನ್ನಿಕಾರ್ನ್ ಕಾಲಾವಧಿಗಳನ್ನು ಹೊಂದಿಸಿದ್ದೀರಿ, ಆದರೆ ಸಮಸ್ಯೆ ಮುಂದುವರಿಯುತ್ತದೆ.

ಮೂಲಸೌಕರ್ಯ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಮತ್ತು ಹಿನ್ನೆಲೆ ಕಾರ್ಯ ನಿರ್ವಹಣೆ ಘರ್ಷಣೆಯಾಗುವ ಒಂದು ಶ್ರೇಷ್ಠ ಸನ್ನಿವೇಶ ಇದು. ಎಡಬ್ಲ್ಯೂಎಸ್ ಸ್ಥಿತಿಸ್ಥಾಪಕ ಬೀನ್‌ಸ್ಟಾಕ್, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಹಿನ್ನೆಲೆ ಕಾರ್ಯವು ಪೂರ್ಣಗೊಳ್ಳುವ ಮೊದಲು ವಿನಂತಿಗಳನ್ನು ಕೊನೆಗೊಳಿಸಬಹುದು. ಇದು ಏಕೆ ಸಂಭವಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಸುತ್ತಲೂ ಹೇಗೆ ಕೆಲಸ ಮಾಡುವುದು ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸುಗಮ ನಿಯೋಜನೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳುವಲ್ಲಿ ಪ್ರಮುಖವಾಗಿದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ಫಾಸ್ಟಾಪಿ ಹಿನ್ನೆಲೆ ಕಾರ್ಯಗಳು ಸ್ಥಿತಿಸ್ಥಾಪಕ ಬೀನ್‌ಸ್ಟಾಕ್‌ನಲ್ಲಿ 502 ದೋಷಗಳನ್ನು ಏಕೆ ಉಂಟುಮಾಡುತ್ತವೆ, ಕಾಲಾವಧಿಗಳನ್ನು ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಹೇಗೆ ಮತ್ತು ನಿಮ್ಮ API ಅನ್ನು ಮನಬಂದಂತೆ ಚಾಲನೆಯಲ್ಲಿಡಲು ಪರ್ಯಾಯ ಪರಿಹಾರಗಳನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ನೀವು ಪಿಡಿಎಫ್ ಪೀಳಿಗೆಯೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತಿರಲಿ, ಡೇಟಾ ಸಂಸ್ಕರಣೆ ಅಥವಾ ಯಾವುದೇ ದೀರ್ಘಾವಧಿಯ ಕಾರ್ಯದೊಂದಿಗೆ, ಈ ಒಳನೋಟಗಳು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿಭಾಯಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ⚡

AWS ಸ್ಥಿತಿಸ್ಥಾಪಕ ಬೀನ್‌ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಫಾಸ್ಟಾಪಿ ಹಿನ್ನೆಲೆ ಕಾರ್ಯಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು

ಫಾಸ್ಟಾಪಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸುವಾಗ AWS ಸ್ಥಿತಿಸ್ಥಾಪಕ ಬೀನ್‌ಸ್ಟಾಕ್, 502 ಕೆಟ್ಟ ಗೇಟ್‌ವೇ ದೋಷಗಳನ್ನು ತಡೆಗಟ್ಟಲು ದೀರ್ಘಕಾಲದ ಹಿನ್ನೆಲೆ ಕಾರ್ಯಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ನಾವು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಫಾಸ್ಟಾಪಿಯನ್ನು ಬಳಸುತ್ತದೆ ಹಿನ್ನೆಲೆ ಟಾಸ್ಕ್ಗಳು ಪಿಡಿಎಫ್ ಪೀಳಿಗೆಯನ್ನು ಅಸಮಕಾಲಿಕವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ವೈಶಿಷ್ಟ್ಯ. ಕಾರ್ಯವು ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ತಕ್ಷಣವೇ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಲು ಇದು API ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಗುನ್ನಿಕಾರ್ನ್ ಮತ್ತು ಎನ್‌ಜಿನ್ಕ್ಸ್ ಹ್ಯಾಂಡಲ್ ವಿನಂತಿ ಕಾಲಾವಧಿಗಳ ಕಾರಣದಿಂದಾಗಿ ಸ್ಥಿತಿಸ್ಥಾಪಕ ಬೀನ್‌ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಈ ವಿಧಾನವು ಸಮಸ್ಯಾತ್ಮಕವಾಗಿರುತ್ತದೆ.

ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು, ನಾವು ಸೆಲರಿ ಮತ್ತು ರೆಡಿಸ್ ಬಳಸಿ ಹೆಚ್ಚು ದೃ solution ವಾದ ಪರಿಹಾರವನ್ನು ಪರಿಚಯಿಸಿದ್ದೇವೆ. ಈ ಸೆಟಪ್‌ನಲ್ಲಿ, ಫಾಸ್ಟಾಪಿ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅದನ್ನು ನೇರವಾಗಿ ನಿರ್ವಹಿಸುವ ಬದಲು ಸೆಲರಿಗೆ ಒಂದು ಕೆಲಸವನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಸೆಲರಿ, ಪ್ರತ್ಯೇಕ ಕೆಲಸಗಾರರ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿದೆ, ಕಾರ್ಯವನ್ನು ಎತ್ತಿಕೊಂಡು ಮುಖ್ಯ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸದೆ ಅದನ್ನು ಅಸಮಕಾಲಿಕವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಸೆಲರಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ನಿರ್ವಹಿಸುವಾಗ ಎಪಿಐ ವಿನಂತಿಯು ತಕ್ಷಣವೇ ಪೂರ್ಣಗೊಳ್ಳುವುದರಿಂದ ಇದು ಸಮಯ ಮೀರಿದ ಸಮಸ್ಯೆಗಳನ್ನು ತಡೆಯುತ್ತದೆ. ಸರಿಯಾದ ಕಾರ್ಯ ನಿಯೋಗವಿಲ್ಲದೆ ಆನ್‌ಲೈನ್ ಅಂಗಡಿ ಇನ್‌ವಾಯ್ಸ್‌ಗಳನ್ನು ಬೃಹತ್ ಪ್ರಮಾಣದಲ್ಲಿ ಉತ್ಪಾದಿಸುವ ಇನ್‌ವಾಯ್ಸ್‌ಗಳನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ, ಎಪಿಐ ಲೋಡ್ ಅಡಿಯಲ್ಲಿ ಹೋರಾಡುತ್ತದೆ. 🚀

ನಾವು ಅನ್ವೇಷಿಸಿದ ಮತ್ತೊಂದು ಪರ್ಯಾಯವೆಂದರೆ AWS SQS (ಸರಳ ಕ್ಯೂ ಸೇವೆ) ಅನ್ನು ನಿಯಂತ್ರಿಸುವುದು. ಆಂತರಿಕ ಕಾರ್ಯ ಕ್ಯೂ ಅನ್ನು ಅವಲಂಬಿಸುವ ಬದಲು, ಈ ವಿಧಾನವು ಹಿನ್ನೆಲೆ ಉದ್ಯೋಗಗಳನ್ನು ನಿರ್ವಹಿಸಿದ ಸಂದೇಶ ಕ್ಯೂಗೆ ತಳ್ಳುತ್ತದೆ. ಬಾಹ್ಯ ಕೆಲಸಗಾರರ ಸೇವೆಯು ಹೊಸ ಕಾರ್ಯಗಳಿಗಾಗಿ ನಿರಂತರವಾಗಿ SQ ಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಅಸಮಕಾಲಿಕವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. ಪ್ರತಿ ಸವಾರಿಯು ಬಹು ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಕಾರ್ಯಗಳನ್ನು ಉತ್ಪಾದಿಸುವ ಸವಾರಿ-ಹಂಚಿಕೆ ಅಪ್ಲಿಕೇಶನ್‌ನಂತಹ ಹೆಚ್ಚಿನ ದಟ್ಟಣೆಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. AWS SQ ಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ನಾವು ಕಾರ್ಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು API ಯಿಂದ ಡಿಕೌಲ್ ಮಾಡುತ್ತೇವೆ, ಸ್ಕೇಲೆಬಿಲಿಟಿ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತೇವೆ.

ಅಂತಿಮವಾಗಿ, ಮುಂಭಾಗದ ಬದಿಯಲ್ಲಿ, ಕಾರ್ಯದ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಲು ನಾವು ಮತದಾನದ ಕಾರ್ಯವಿಧಾನವನ್ನು ಜಾರಿಗೆ ತಂದಿದ್ದೇವೆ. ಹಿನ್ನೆಲೆ ಕಾರ್ಯವು ಸುಮಾರು 30 ಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದರಿಂದ, ಪಿಡಿಎಫ್ ಸಿದ್ಧವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಮುಂಭಾಗವು ನಿಯತಕಾಲಿಕವಾಗಿ ಎಪಿಐ ಅನ್ನು ಪ್ರಶ್ನಿಸಬೇಕು. ನಿರಂತರ ವಿನಂತಿಗಳೊಂದಿಗೆ ಸರ್ವರ್ ಅನ್ನು ಮುಳುಗಿಸುವ ಬದಲು, ನಾವು ಮಧ್ಯಂತರ ಆಧಾರಿತ ವಿಧಾನವನ್ನು ಜಾರಿಗೆ ತಂದಿದ್ದೇವೆ ಅದು ಪ್ರತಿ 5 ಸೆಕೆಂಡಿಗೆ ಸೀಮಿತ ಸಂಖ್ಯೆಯ ಪ್ರಯತ್ನಗಳಿಗಾಗಿ ಮರುಪಡೆಯುತ್ತದೆ. ಅನಗತ್ಯ API ಲೋಡ್ ಅನ್ನು ತಪ್ಪಿಸುವಾಗ ಮುಂಭಾಗವು ಸ್ಪಂದಿಸುತ್ತದೆ ಎಂದು ಇದು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ. ಈ ಕಾರ್ಯತಂತ್ರದೊಂದಿಗೆ, ತೆರಿಗೆ ವರದಿಗಳಂತಹ ಡಾಕ್ಯುಮೆಂಟ್ ಪೀಳಿಗೆಯನ್ನು ವಿನಂತಿಸುವ ಬಳಕೆದಾರರು ಕಾಯುತ್ತಿರುವಾಗ ಸ್ಪಂದಿಸದ ಯುಐಗಳನ್ನು ಅನುಭವಿಸುವುದಿಲ್ಲ. 📄✅

from fastapi import FastAPI, BackgroundTasks
from celery import Celery
import time
app = FastAPI()
celery = Celery("tasks", broker="redis://localhost:6379/0")
@celery.task
def generate_pdf_task(order_id: str):
    print(f"Generating PDF for order {order_id}")
    time.sleep(30)  # Simulating long processing time
    return f"PDF generated for order {order_id}"
@app.post("/generate-pdf/{order_id}")
async def generate_pdf(order_id: str, background_tasks: BackgroundTasks):
    background_tasks.add_task(generate_pdf_task, order_id)
    return {"message": "PDF generation started"}

import boto3
from fastapi import FastAPI
app = FastAPI()
sqs = boto3.client('sqs', region_name='us-east-1')
queue_url = "https://sqs.us-east-1.amazonaws.com/your-account-id/your-queue-name"
@app.post("/generate-pdf/{order_id}")
async def generate_pdf(order_id: str):
    response = sqs.send_message(
        QueueUrl=queue_url,
        MessageBody=str(order_id)
    )
    return {"message": "PDF generation request sent", "message_id": response['MessageId']}

async function checkPdfStatus(orderId) {
    let attempts = 0;
    const maxAttempts = 5;
    while (attempts < maxAttempts) {
        const response = await fetch(`/get-pdf-url/${orderId}`);
        const data = await response.json();
        if (data.pdf_url) {
            console.log("PDF available at:", data.pdf_url);
            return;
        }
        attempts++;
        await new Promise(resolve => setTimeout(resolve, 5000));
    }
    console.log("PDF generation timed out.");
}

from fastapi.testclient import TestClient
from main import app
client = TestClient(app)
def test_generate_pdf():
    response = client.post("/generate-pdf/test_order")
    assert response.status_code == 200
    assert response.json() == {"message": "PDF generation started"}

ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳೊಂದಿಗೆ ಫಾಸ್ಟಾಪಿ ಹಿನ್ನೆಲೆ ಕಾರ್ಯ ನಿರ್ವಹಣೆಯನ್ನು ಹೆಚ್ಚಿಸುವುದು

ಹಿನ್ನೆಲೆ ಕಾರ್ಯಗಳೊಂದಿಗೆ ಒಂದು ಸವಾಲು ದರ್ಜೆ ಅಸಮರ್ಥ ಮತದಾನವನ್ನು ಅವಲಂಬಿಸದೆ ಬಳಕೆದಾರರಿಗೆ ನೈಜ-ಸಮಯದ ನವೀಕರಣಗಳನ್ನು ಒದಗಿಸುತ್ತಿದೆ. ಉತ್ತಮ ಪರ್ಯಾಯವನ್ನು ಬಳಸುವುದು ವೆಬ್‌ಸಾಕೆಟ್, ಇದು ಕ್ಲೈಂಟ್ ಮತ್ತು ಸರ್ವರ್ ನಡುವೆ ದ್ವಿಮುಖ ಸಂವಹನವನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಕಾರ್ಯದ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಲು ಎಂಡ್‌ಪೋಯಿಂಟ್ ಅನ್ನು ಪದೇ ಪದೇ ಪ್ರಶ್ನಿಸುವ ಬದಲು, ಪ್ರಗತಿ ಇದ್ದಾಗಲೆಲ್ಲಾ ಬ್ಯಾಕೆಂಡ್ ನವೀಕರಣಗಳನ್ನು ಕಳುಹಿಸಬಹುದು.

ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳೊಂದಿಗೆ, ಬಳಕೆದಾರರು ಪಿಡಿಎಫ್ ಪೀಳಿಗೆಯನ್ನು ವಿನಂತಿಸಿದಾಗ, ಸರ್ವರ್ ತಕ್ಷಣ ವಿನಂತಿಯನ್ನು ಅಂಗೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಕಾರ್ಯವು ಮುಂದುವರೆದಂತೆ, ವೆಬ್‌ಸಾಕೆಟ್ ಸಂದೇಶಗಳು ಕ್ಲೈಂಟ್‌ಗೆ “ಸಂಸ್ಕರಣೆ,” “ಅಪ್‌ಲೋಡ್,” ಮತ್ತು “ಪೂರ್ಣಗೊಂಡಿದೆ” ಎಂಬ ವಿವಿಧ ಹಂತಗಳ ಬಗ್ಗೆ ತಿಳಿಸಬಹುದು. ಇದು ಅನಗತ್ಯ API ಕರೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಇ-ಕಾಮರ್ಸ್ ಸರಕುಪಟ್ಟಿ ಉತ್ಪಾದನೆ ಅಥವಾ ವರದಿ ಡೌನ್‌ಲೋಡ್‌ಗಳಂತಹ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ. 🚀

ಫಾಸ್ಟಾಪಿಯಲ್ಲಿ ವೆಬ್‌ಸಾಕೆಟ್‌ಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಲು ಬಳಸುವುದು ಅಗತ್ಯವಿದೆ ಕಸಿ ಮತ್ತು ವೆಬ್‌ಸಾಕೆಟ್ ಮಾಡ್ಯೂಲ್. ಮುಂಭಾಗವು ನವೀಕರಣಗಳನ್ನು ಆಲಿಸಿದಾಗ ವೆಬ್‌ಸಾಕೆಟ್ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಬ್ಯಾಕೆಂಡ್ ನೈಜ-ಸಮಯದ ಸಂದೇಶಗಳನ್ನು ತಳ್ಳುತ್ತದೆ. ಸಾಂಪ್ರದಾಯಿಕ ಮತದಾನಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಈ ವಿಧಾನವು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ ಮತ್ತು ಹಣಕಾಸಿನ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗಳು ಮತ್ತು ಸಹಕಾರಿ ಸಂಪಾದನೆ ಸಾಧನಗಳಂತಹ ತ್ವರಿತ ನವೀಕರಣಗಳ ಅಗತ್ಯವಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಇದನ್ನು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.