FastAPI 'ਤੇ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਅਪਲੋਡ ਕਰਨ ਵੇਲੇ ਡੌਕਰ ਕੰਪੋਜ਼ ਵਿੱਚ 502 ਖਰਾਬ ਗੇਟਵੇ ਗਲਤੀਆਂ ਨੂੰ ਠੀਕ ਕਰਨਾ

ਫਾਈਲ ਅਪਲੋਡ ਦੌਰਾਨ ਡੌਕਰ 502 ਗਲਤੀਆਂ ਦਾ ਨਿਪਟਾਰਾ ਕਰਨਾ

FastAPI, ਡੌਕਰ ਕੰਪੋਜ਼, ਅਤੇ ਫਾਈਲ ਅਪਲੋਡਸ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਤੁਹਾਨੂੰ ਕਦੇ-ਕਦਾਈਂ ਗਲਤੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈ ਸਕਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਅਪਲੋਡਾਂ ਨਾਲ। ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਰਿਪੋਰਟ ਕੀਤੀ ਇੱਕ ਆਮ ਸਮੱਸਿਆ ਹੈ a 502 ਬੈਡ ਗੇਟਵੇ ਗਲਤੀ, ਖਾਸ ਤੌਰ 'ਤੇ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਅੱਪਲੋਡ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ, ਜਿਵੇਂ ਕਿ 120MB .7z ਆਰਕਾਈਵ।

ਇਸ ਕਿਸਮ ਦੀ ਗਲਤੀ ਕਈ ਕਾਰਨਾਂ ਕਰਕੇ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਸਰਵਰ ਟਾਈਮਆਉਟ, ਡੌਕਰ ਵਿੱਚ ਸੰਰਚਨਾ ਸੀਮਾਵਾਂ, ਜਾਂ ਇੱਥੋਂ ਤੱਕ ਕਿ ਰਿਵਰਸ ਪ੍ਰੌਕਸੀ ਸਮੱਸਿਆਵਾਂ ਜਿਵੇਂ ਕਿ Nginx ਨਾਲ ਆਈਆਂ ਹਨ। ਮੂਲ ਕਾਰਨ ਨੂੰ ਸਮਝਣਾ ਇਹਨਾਂ ਲਗਾਤਾਰ ਅੱਪਲੋਡ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਕੁੰਜੀ ਹੈ।

ਜੇਕਰ ਤੁਸੀਂ ਅੱਪਲੋਡ ਕਰਨ ਲਈ FastAPI ਦੇ Swagger UI ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਰਿਫ੍ਰੈਸ਼ ਜਾਂ ਕ੍ਰੈਸ਼ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹੋ, ਖਾਸ ਤੌਰ 'ਤੇ ਛੋਟੀਆਂ ਫਾਈਲਾਂ ਅੱਪਲੋਡਾਂ ਦੇ ਨਾਲ ਦੇਖ ਸਕਦੇ ਹੋ। ਇਹ ਲੱਛਣ ਅਸੰਗਤ ਵਿਵਹਾਰ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੇ ਹਨ ਅਤੇ ਹੋਰ ਡੀਬੱਗਿੰਗ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਇਸ ਗਾਈਡ ਵਿੱਚ, ਅਸੀਂ ਇਹ ਪਤਾ ਲਗਾਵਾਂਗੇ ਕਿ ਇਹਨਾਂ ਤਰੁਟੀਆਂ ਦਾ ਕਾਰਨ ਕੀ ਹੋ ਸਕਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਫਾਈਲ ਆਕਾਰ ਸੀਮਾਵਾਂ, ਰਿਵਰਸ ਪ੍ਰੌਕਸੀ ਗਲਤ ਸੰਰਚਨਾਵਾਂ, ਜਾਂ ਤੁਹਾਡੇ ਵਿੱਚ ਹੋਰ ਬੈਕਐਂਡ ਸਮੱਸਿਆਵਾਂ ਸ਼ਾਮਲ ਹਨ ਡੌਕਰ ਕੰਪੋਜ਼ ਵਾਤਾਵਰਣ. ਅਸੀਂ FastAPI ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਫਾਈਲ ਅਪਲੋਡਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਆਵਰਤੀ ਤਰੁਟੀਆਂ ਨੂੰ ਰੋਕਣ ਲਈ ਸੰਭਾਵੀ ਹੱਲਾਂ ਦੀ ਵੀ ਪੜਚੋਲ ਕਰਾਂਗੇ।

ਡੌਕਰ ਕੰਪੋਜ਼ ਨਾਲ FastAPI ਵਿੱਚ 502 ਗਲਤੀ ਦੇ ਹੱਲ ਨੂੰ ਸਮਝਣਾ

ਪਹਿਲਾਂ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਉਦੇਸ਼ FastAPI ਅਤੇ ਡੌਕਰ ਕੰਪੋਜ਼ ਰਾਹੀਂ ਵੱਡੀਆਂ ਫਾਈਲਾਂ, ਖਾਸ ਤੌਰ 'ਤੇ 120MB .7z ਆਰਕਾਈਵ ਨੂੰ ਅੱਪਲੋਡ ਕਰਨ ਦੇ ਮੁੱਦੇ ਨਾਲ ਨਜਿੱਠਣਾ ਹੈ। ਮੁੱਖ ਤੱਤਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਵਰਤੋਂ ਹੈ ਪਿਛੋਕੜ ਕਾਰਜ FastAPI ਵਿੱਚ। ਦਾ ਲਾਭ ਉਠਾ ਕੇ background_tasks.add_task() ਕਮਾਂਡ, ਫਾਈਲ ਐਕਸਟਰੈਕਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਅਸਿੰਕ੍ਰੋਨਸ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ, ਭਾਵ ਇਹ ਮੁੱਖ ਬੇਨਤੀ ਚੱਕਰ ਨੂੰ ਬਲੌਕ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦੇ ਸਮੇਂ ਸਮਾਂ ਸਮਾਪਤੀ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਰੋਕਣ ਲਈ ਇਹ ਜ਼ਰੂਰੀ ਹੈ। ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਤੋਂ ਬਿਨਾਂ, FastAPI ਮੁੱਖ ਥ੍ਰੈਡ ਵਿੱਚ ਹਰ ਚੀਜ਼ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੇਗਾ, ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਇੱਕ 502 ਖਰਾਬ ਗੇਟਵੇ ਗਲਤੀ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੀ ਹੈ ਜੇਕਰ ਸਰਵਰ ਜਵਾਬ ਦੇਣ ਵਿੱਚ ਬਹੁਤ ਸਮਾਂ ਲੈਂਦਾ ਹੈ।

ਇਕ ਹੋਰ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਹੈ shutil.copyfileobj() ਵਿਧੀ, ਜੋ ਅਪਲੋਡ ਕੀਤੀ ਫਾਈਲ ਨੂੰ ਡਿਸਕ 'ਤੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਲਿਖਦੀ ਹੈ। ਇਹ ਫੰਕਸ਼ਨ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਕਿਉਂਕਿ ਇਹ ਫਾਈਲ ਸਟ੍ਰੀਮ ਤੋਂ ਟੁਕੜਿਆਂ ਵਿੱਚ ਪੜ੍ਹਦਾ ਹੈ, ਮੈਮੋਰੀ ਓਵਰਲੋਡ ਨੂੰ ਰੋਕਦਾ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ UUID ਫੰਕਸ਼ਨ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਓਵਰਰਾਈਟਿੰਗ ਨੂੰ ਰੋਕਣ ਲਈ ਹਰੇਕ ਫਾਈਲ ਨੂੰ ਇੱਕ ਵਿਲੱਖਣ ਨਾਮ ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ, ਜੋ ਕਿ ਵਾਤਾਵਰਣ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ ਜਿੱਥੇ ਇੱਕ ਤੋਂ ਵੱਧ ਉਪਭੋਗਤਾ ਇੱਕੋ ਸਮੇਂ ਫਾਈਲਾਂ ਨੂੰ ਅਪਲੋਡ ਕਰ ਸਕਦੇ ਹਨ। ਜੇਕਰ ਕੋਈ ਫ਼ਾਈਲ ਨਾਮ ਵਿਲੱਖਣ ਨਹੀਂ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਅੱਪਲੋਡ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਫ਼ਾਈਲ ਭ੍ਰਿਸ਼ਟਾਚਾਰ ਜਾਂ ਵਿਵਾਦਾਂ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈ ਸਕਦਾ ਹੈ।

ਡੌਕਰ ਕੰਪੋਜ਼ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ FastAPI ਸਰਵਰ ਲਈ ਸਮਾਂ ਸਮਾਪਤ ਕਰਨ ਲਈ ਕੌਂਫਿਗਰ ਕੀਤੀ ਗਈ ਹੈ ਯੂਵੀਕੋਰਨ --ਟਾਈਮਆਊਟ-ਕੀਪ-ਲਾਈਵ ਵਿਕਲਪ। ਇਹ ਕਮਾਂਡ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਸਰਵਰ ਕਲਾਇੰਟ ਨਾਲ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਕਨੈਕਸ਼ਨ ਬਣਾ ਸਕਦਾ ਹੈ, ਭਾਵੇਂ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਅੱਪਲੋਡ ਕਰਨ ਵਿੱਚ ਕਾਫ਼ੀ ਸਮਾਂ ਲੱਗੇ। ਇਸਨੂੰ 300 ਸਕਿੰਟਾਂ (ਜਾਂ 5 ਮਿੰਟ) 'ਤੇ ਸੈੱਟ ਕਰਕੇ, ਇਹ ਡੌਕਰ ਨੂੰ ਸਮੇਂ ਤੋਂ ਪਹਿਲਾਂ ਕੁਨੈਕਸ਼ਨ ਬੰਦ ਕਰਨ ਤੋਂ ਰੋਕਦਾ ਹੈ, ਜਿਸਦਾ ਨਤੀਜਾ ਅਕਸਰ 502 ਗਲਤੀ ਹੁੰਦਾ ਹੈ। ਇਹ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ ਵਾਲੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੌਰਾਨ ਸਥਿਰਤਾ ਬਣਾਈ ਰੱਖਣ ਵਿੱਚ ਵੀ ਮਦਦ ਕਰਦਾ ਹੈ।

ਅੰਤ ਵਿੱਚ, Nginx ਕੌਂਫਿਗਰੇਸ਼ਨ ਸੈਟ ਕਰਕੇ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਅਪਲੋਡ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਣ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਣ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦੀ ਹੈ ਕਲਾਇੰਟ_ਮੈਕਸ_ਬਾਡੀ_ਸਾਈਜ਼ 200MB ਲਈ ਨਿਰਦੇਸ਼. ਇਹ ਬਦਲਾਅ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ Nginx 1MB ਦੀ ਡਿਫੌਲਟ ਸੀਮਾ ਤੋਂ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰ ਸਕਦਾ ਹੈ। ਦੇ ਨਾਲ ਜੋੜਿਆ ਗਿਆ proxy_read_timeout ਡਾਇਰੈਕਟਿਵ, ਜੋ ਸਰਵਰ ਨੂੰ ਬੈਕਐਂਡ ਸਰਵਰ ਦੇ ਜਵਾਬ ਲਈ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਉਡੀਕ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਇਹ ਸੈਟਿੰਗਾਂ ਉਹਨਾਂ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀਆਂ ਹਨ ਜੋ ਹੌਲੀ ਜਾਂ ਵੱਡੀ ਫਾਈਲ ਟ੍ਰਾਂਸਫਰ ਤੋਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। ਇਕੱਠੇ ਮਿਲ ਕੇ, ਇਹ ਆਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਤੁਹਾਡੀ FastAPI ਐਪਲੀਕੇਸ਼ਨ ਡੌਕਰ ਕੰਪੋਜ਼ ਵਾਤਾਵਰਨ ਵਿੱਚ 502 ਤਰੁੱਟੀਆਂ ਨੂੰ ਕ੍ਰੈਸ਼ ਕੀਤੇ ਜਾਂ ਪੈਦਾ ਕੀਤੇ ਬਿਨਾਂ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਅੱਪਲੋਡਾਂ ਨੂੰ ਸੰਭਾਲ ਸਕਦੀ ਹੈ।

# This FastAPI function handles large file uploads using background tasks.
from fastapi import FastAPI, UploadFile, File, BackgroundTasks, HTTPException, status
import os, shutil, uuid
from fastapi.responses import JSONResponse
app = FastAPI()
UPLOAD_DIR = "/app/uploads"
@app.post("/7zip/")
async def upload_7zip(background_tasks: BackgroundTasks, archive_file: UploadFile = File(...)):
    # Check if the uploaded file is a valid .7z file
    if not archive_file.filename.endswith(".7z"):
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Please upload a valid 7z file.")
    # Generate a unique filename to prevent overwrites
    archive_filename = f"{uuid.uuid4()}_{archive_file.filename}"
    archive_path = os.path.join(UPLOAD_DIR, archive_filename)
    try:
        # Save the uploaded file to the server
        with open(archive_path, "wb") as buffer:
            shutil.copyfileobj(archive_file.file, buffer)
        # Add file extraction to background tasks to avoid timeouts
        background_tasks.add_task(extract_file, archive_path)
        return JSONResponse({"message": "File uploaded successfully, extraction is in progress."})
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"An error occurred while processing the 7z file: {str(e)}")
# Background task to extract files
def extract_file(archive_path: str):
    # Placeholder function for extracting 7z files
    pass

# Adjusting Nginx configuration to allow larger file uploads
server {
    listen 80;
    server_name example.com;
    location / {
        proxy_pass http://app:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
    # Set the maximum allowed upload size to 200MB
    client_max_body_size 200M;
    proxy_read_timeout 300;
}

# Docker Compose file with increased timeout to avoid 502 errors
version: '3'
services:
  app:
    container_name: fastapi_app
    build: .
    command: bash -c "uvicorn main:app --host 0.0.0.0 --port 8000 --timeout-keep-alive=300"
    ports:
      - "8000:8000"
    volumes:
      - ./uploads:/app/uploads
    depends_on:
      - db
    restart: always
    environment:
      - FASTAPI_ENV=production
  db:
    image: postgres
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass

ਡੌਕਰ ਕੰਪੋਜ਼ ਨਾਲ ਫਾਸਟ ਏਪੀਆਈ ਵਿੱਚ ਫਾਈਲ ਸਾਈਜ਼ ਦੇ ਮੁੱਦਿਆਂ ਨੂੰ ਦੂਰ ਕਰਨਾ

ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਜੋ ਕਿ ਫਾਈਲ ਅੱਪਲੋਡ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ ਡੌਕਰ ਕੰਪੋਜ਼ ਵਾਤਾਵਰਣ ਮੈਮੋਰੀ ਅਤੇ ਟਾਈਮਆਉਟ ਲਈ ਸਰਵਰ ਸੀਮਾਵਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਹੈ। ਸਰਵਰ ਟਾਈਮਆਉਟ ਐਡਜਸਟਮੈਂਟਸ ਅਤੇ ਰਿਵਰਸ ਪ੍ਰੌਕਸੀ ਕੌਂਫਿਗਰੇਸ਼ਨਾਂ ਤੋਂ ਇਲਾਵਾ, ਫਾਈਲ ਅਪਲੋਡ ਸਿਸਟਮ-ਪੱਧਰ ਦੀਆਂ ਰੁਕਾਵਟਾਂ, ਜਿਵੇਂ ਕਿ ਉਪਲਬਧ ਮੈਮੋਰੀ ਅਤੇ CPU ਸਰੋਤਾਂ ਦੁਆਰਾ ਵੀ ਪ੍ਰਭਾਵਿਤ ਹੋ ਸਕਦੇ ਹਨ। 120MB .7z ਪੁਰਾਲੇਖ ਵਰਗੀ ਇੱਕ ਵੱਡੀ ਫਾਈਲ ਨੂੰ ਅੱਪਲੋਡ ਕਰਨ ਵੇਲੇ, ਸਰਵਰ ਮੈਮੋਰੀ ਥਕਾਵਟ ਜਾਂ ਉੱਚ CPU ਉਪਯੋਗਤਾ ਵਿੱਚ ਚਲਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਇਹ ਮੱਧ-ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਰੈਸ਼ ਜਾਂ ਤਾਜ਼ਾ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਉਦੋਂ ਹੋਰ ਵੀ ਵਧ ਸਕਦਾ ਹੈ ਜਦੋਂ ਕਈ ਉਪਭੋਗਤਾ ਇੱਕੋ ਸਮੇਂ ਫਾਈਲਾਂ ਨੂੰ ਅਪਲੋਡ ਕਰ ਰਹੇ ਹਨ।

ਇਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਨੁਕਤਾ ਇਹ ਹੈ ਕਿ ਫਾਈਲ ਅਪਲੋਡ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਕੰਟੇਨਰਾਈਜ਼ੇਸ਼ਨ ਦੇ ਕਾਰਨ ਘਟ ਸਕਦੀ ਹੈ। ਡੌਕਰ ਪ੍ਰਤੀ ਕੰਟੇਨਰ ਸਰੋਤਾਂ ਨੂੰ ਅਲੱਗ ਕਰਦਾ ਹੈ, ਮਤਲਬ ਕਿ ਜਦੋਂ ਤੱਕ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਰਚਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ, ਇੱਕ ਕੰਟੇਨਰ ਕੋਲ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸੰਭਾਲਣ ਲਈ ਲੋੜੀਂਦੇ ਸਰੋਤ ਨਹੀਂ ਹੋ ਸਕਦੇ ਹਨ। ਇਸ ਨਾਲ ਛੋਟੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵੇਲੇ ਸਰਵਰ ਰਿਫ੍ਰੈਸ਼ ਹੋ ਸਕਦਾ ਹੈ ਜਾਂ ਕ੍ਰੈਸ਼ ਹੋ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ 16-17 MB ਰੇਂਜ ਜਿਸ ਦਾ ਤੁਸੀਂ ਅਨੁਭਵ ਕੀਤਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਤੁਹਾਡੇ ਡੌਕਰ ਕੰਟੇਨਰਾਂ ਵਿੱਚ ਲੋੜੀਂਦੇ CPU ਅਤੇ ਮੈਮੋਰੀ ਸਰੋਤ ਨਿਰਧਾਰਤ ਕੀਤੇ ਗਏ ਹਨ, ਅਤੇ ਸੀਮਾਵਾਂ ਨੂੰ ਅਸਲ-ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ ਟੈਸਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਅੰਤ ਵਿੱਚ, FastAPI ਦੀ ਬੇਨਤੀ ਹੈਂਡਲਿੰਗ ਨੂੰ ਸਟ੍ਰੀਮਿੰਗ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਕੂਲਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ ਚੰਕਡ ਫਾਈਲ ਅਪਲੋਡਸ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ। ਇਹ ਸਰਵਰ ਦੀ ਮੈਮੋਰੀ ਨੂੰ ਹਾਵੀ ਕੀਤੇ ਬਿਨਾਂ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ। Nginx, Uvicorn, ਅਤੇ Docker ਸਰੋਤ ਵੰਡ ਦੀ ਸਹੀ ਸੰਰਚਨਾ ਦੇ ਨਾਲ ਮਿਲਾ ਕੇ, ਸਟ੍ਰੀਮਿੰਗ ਤੁਹਾਡੇ API ਨੂੰ ਹੋਰ ਮਜਬੂਤ ਬਣਾ ਸਕਦੀ ਹੈ। ਉਤਪਾਦਨ ਵਾਤਾਵਰਣ ਵਿੱਚ ਵੱਡੇ ਜਾਂ ਸਮਕਾਲੀ ਫਾਈਲ ਅਪਲੋਡਾਂ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਇਹਨਾਂ ਵਾਧੂ ਅਨੁਕੂਲਤਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਬਿਹਤਰ ਸਥਿਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ।