FastAPI ഫയൽ അപ്‌ലോഡുകളിൽ വൈദഗ്ദ്ധ്യം നേടാം: മൾട്ടിപാർട്ട് ഫോം പ്രോസസ്സിംഗിനെക്കുറിച്ചുള്ള സമഗ്രമായ വിശകലനം

ആധുനിക വെബ് ആപ്ലിക്കേഷനുകളിൽ, ഫയൽ അപ്‌ലോഡുകൾ കൈകാര്യം ചെയ്യാനുള്ള കഴിവ് ഒരു അടിസ്ഥാന ആവശ്യകതയാണ്. ഉപയോക്താക്കൾ പ്രൊഫൈൽ ചിത്രങ്ങൾ സമർപ്പിക്കുന്നതായാലും, പ്രോസസ്സിംഗിനായി ഡോക്യുമെന്റുകൾ നൽകുന്നതായാലും, അല്ലെങ്കിൽ പങ്കുവെക്കുന്നതിനായി മീഡിയ നൽകുന്നതായാലും, ശക്തവും കാര്യക്ഷമവുമായ ഫയൽ അപ്‌ലോഡ് സംവിധാനങ്ങൾ നിർണായകമാണ്. ഉയർന്ന പ്രകടനം കാഴ്ചവെക്കുന്ന പൈത്തൺ വെബ് ഫ്രെയിംവർക്കായ FastAPI ഈ രംഗത്ത് മികച്ചുനിൽക്കുന്നു, ഇത് മൾട്ടിപാർട്ട് ഫോം ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ലളിതമായ വഴികൾ വാഗ്ദാനം ചെയ്യുന്നു, എച്ച്ടിടിപി വഴി ഫയലുകൾ അയക്കുന്നതിനുള്ള സ്റ്റാൻഡേർഡ് ഇതാണ്. ഈ സമഗ്രമായ ഗൈഡ് FastAPI ഫയൽ അപ്‌ലോഡുകളുടെ സങ്കീർണ്ണതകളിലൂടെ നിങ്ങളെ നയിക്കും, അടിസ്ഥാനപരമായ നിർവ്വഹണം മുതൽ നൂതനമായ പരിഗണനകൾ വരെ, ആഗോള പ്രേക്ഷകർക്കായി ശക്തവും സ്കെയിലബിളുമായ API-കൾ ആത്മവിശ്വാസത്തോടെ നിർമ്മിക്കാൻ നിങ്ങൾക്ക് കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.

മൾട്ടിപാർട്ട് ഫോം ഡാറ്റ മനസ്സിലാക്കാം

FastAPI-യുടെ നിർവ്വഹണത്തിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, മൾട്ടിപാർട്ട് ഫോം ഡാറ്റ എന്താണെന്ന് മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്. ഒരു വെബ് ബ്രൗസർ ഫയലുകൾ അടങ്ങുന്ന ഒരു ഫോം സമർപ്പിക്കുമ്പോൾ, അത് സാധാരണയായി enctype="multipart/form-data" എന്ന ആട്രിബ്യൂട്ട് ഉപയോഗിക്കുന്നു. ഈ എൻകോഡിംഗ് തരം ഫോം സമർപ്പണത്തെ ഒന്നിലധികം ഭാഗങ്ങളായി വിഭജിക്കുന്നു, ഓരോന്നിനും അതിൻ്റേതായ ഉള്ളടക്ക തരവും ഡിസ്പോസിഷൻ വിവരങ്ങളും ഉണ്ട്. ടെക്സ്റ്റ് ഫീൽഡുകൾ, നോൺ-ടെക്സ്റ്റ് ഫീൽഡുകൾ, ബൈനറി ഫയലുകൾ എന്നിവയുൾപ്പെടെ ഒരൊറ്റ എച്ച്ടിടിപി അഭ്യർത്ഥനയിൽ വ്യത്യസ്ത തരം ഡാറ്റ കൈമാറാൻ ഇത് അനുവദിക്കുന്നു.

ഒരു മൾട്ടിപാർട്ട് അഭ്യർത്ഥനയിലെ ഓരോ ഭാഗത്തും ഇവ അടങ്ങിയിരിക്കുന്നു:

• ഉള്ളടക്ക-വിന്യാസ ഹെഡർ (Content-Disposition Header): ഫോം ഫീൽഡിൻ്റെ പേരും (name), ഫയലുകൾക്കായി യഥാർത്ഥ ഫയൽനാമവും (filename) വ്യക്തമാക്കുന്നു.
• ഉള്ളടക്ക-തരം ഹെഡർ (Content-Type Header): ഭാഗത്തിൻ്റെ MIME തരം സൂചിപ്പിക്കുന്നു (ഉദാഹരണത്തിന്, text/plain, image/jpeg).
• ബോഡി (Body): ആ ഭാഗത്തിനായുള്ള യഥാർത്ഥ ഡാറ്റ.

ഫയൽ അപ്‌ലോഡുകളോടുള്ള FastAPI-യുടെ സമീപനം

FastAPI പൈത്തണിൻ്റെ സ്റ്റാൻഡേർഡ് ലൈബ്രറി പ്രയോജനപ്പെടുത്തുകയും ഡാറ്റാ വാലിഡേഷനായി Pydantic-മായി തടസ്സമില്ലാതെ സംയോജിപ്പിക്കുകയും ചെയ്യുന്നു. ഫയൽ അപ്‌ലോഡുകൾക്കായി, ഇത് fastapi മൊഡ്യൂളിൽ നിന്നുള്ള UploadFile തരം ഉപയോഗിക്കുന്നു. ഈ ക്ലാസ് അപ്‌ലോഡ് ചെയ്ത ഫയൽ ഡാറ്റ ആക്‌സസ് ചെയ്യുന്നതിന് സൗകര്യപ്രദവും സുരക്ഷിതവുമായ ഒരു ഇൻ്റർഫേസ് നൽകുന്നു.

അടിസ്ഥാന ഫയൽ അപ്‌ലോഡ് നിർവ്വഹണം

ഒരൊറ്റ ഫയൽ അപ്‌ലോഡ് സ്വീകരിക്കുന്ന FastAPI-യിൽ ഒരു എൻഡ്‌പോയിൻ്റ് എങ്ങനെ സൃഷ്ടിക്കാമെന്നതിൻ്റെ ലളിതമായ ഉദാഹരണത്തിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം. ഫയൽ പാരാമീറ്റർ പ്രഖ്യാപിക്കാൻ നമ്മൾ fastapi-യിൽ നിന്നുള്ള File ഫംഗ്ഷൻ ഉപയോഗിക്കും.

            from fastapi import FastAPI, File, UploadFile

app = FastAPI()

@app.post("/files/")
async def create_file(file: UploadFile):
    return {"filename": file.filename, "content_type": file.content_type}

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ:

• നമ്മൾ FastAPI, File, UploadFile എന്നിവ ഇമ്പോർട്ട് ചെയ്യുന്നു.
• /files/ എന്ന എൻഡ്‌പോയിൻ്റ് ഒരു POST അഭ്യർത്ഥനയായി നിർവചിച്ചിരിക്കുന്നു.
• file എന്ന പാരാമീറ്ററിനെ UploadFile ഉപയോഗിച്ച് അടയാളപ്പെടുത്തിയിരിക്കുന്നു, ഇത് ഒരു ഫയൽ അപ്‌ലോഡ് പ്രതീക്ഷിക്കുന്നു എന്ന് സൂചിപ്പിക്കുന്നു.
• എൻഡ്‌പോയിൻ്റ് ഫംഗ്ഷനുള്ളിൽ, അപ്‌ലോഡ് ചെയ്ത ഫയലിൻ്റെ filename, content_type തുടങ്ങിയ പ്രോപ്പർട്ടികൾ നമുക്ക് ആക്സസ് ചെയ്യാൻ കഴിയും.

ഒരു ക്ലയൻ്റ് ഒരു ഫയൽ അറ്റാച്ചുചെയ്ത് (സാധാരണയായി enctype="multipart/form-data" ഉള്ള ഒരു ഫോം വഴി) /files/ എന്നതിലേക്ക് ഒരു POST അഭ്യർത്ഥന അയയ്‌ക്കുമ്പോൾ, FastAPI യാന്ത്രികമായി പാഴ്‌സിംഗ് കൈകാര്യം ചെയ്യുകയും ഒരു UploadFile ഒബ്ജക്റ്റ് നൽകുകയും ചെയ്യും. അതിനുശേഷം നിങ്ങൾക്ക് ഈ ഒബ്ജക്റ്റുമായി സംവദിക്കാൻ കഴിയും.

അപ്‌ലോഡ് ചെയ്ത ഫയലുകൾ സേവ് ചെയ്യുന്നു

പലപ്പോഴും, അപ്‌ലോഡ് ചെയ്ത ഫയൽ ഡിസ്കിലേക്ക് സേവ് ചെയ്യുകയോ അതിലെ ഉള്ളടക്കം പ്രോസസ്സ് ചെയ്യുകയോ ചെയ്യേണ്ടിവരും. UploadFile ഒബ്ജക്റ്റ് ഇതിനായി മെത്തേഡുകൾ നൽകുന്നു:

• read(): ഫയലിൻ്റെ മുഴുവൻ ഉള്ളടക്കവും ബൈറ്റുകളായി മെമ്മറിയിലേക്ക് വായിക്കുന്നു. ചെറിയ ഫയലുകൾക്കായി ഇത് ഉപയോഗിക്കുക.
• write(content: bytes): ഫയലിലേക്ക് ബൈറ്റുകൾ എഴുതുന്നു.
• seek(offset: int): നിലവിലെ ഫയൽ സ്ഥാനം മാറ്റുന്നു.
• close(): ഫയൽ അടയ്ക്കുന്നു.

പ്രത്യേകിച്ച് വലിയ ഫയലുകൾ അല്ലെങ്കിൽ I/O-ബൗണ്ട് ജോലികൾ കൈകാര്യം ചെയ്യുമ്പോൾ ഫയൽ പ്രവർത്തനങ്ങൾ അസിൻക്രണസ് ആയി കൈകാര്യം ചെയ്യേണ്ടത് പ്രധാനമാണ്. FastAPI-യുടെ UploadFile അസിൻക്രണസ് പ്രവർത്തനങ്ങളെ പിന്തുണയ്ക്കുന്നു.

            from fastapi import FastAPI, File, UploadFile
import shutil

app = FastAPI()

@app.post("/files/save/")
async def save_file(file: UploadFile = File(...)):
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())
    return {"info": f"file '{file.filename}' saved at '{file_location}'"}

            

              
                Copy
              
            
          

ഈ മെച്ചപ്പെടുത്തിയ ഉദാഹരണത്തിൽ:

• ഈ പാരാമീറ്റർ ആവശ്യമാണെന്ന് സൂചിപ്പിക്കാൻ നമ്മൾ File(...) ഉപയോഗിക്കുന്നു.
• ഫയൽ സേവ് ചെയ്യേണ്ട ഒരു ലോക്കൽ പാത നമ്മൾ വ്യക്തമാക്കുന്നു. uploads ഡയറക്ടറി നിലവിലുണ്ടെന്ന് ഉറപ്പാക്കുക.
• നമ്മൾ ഡെസ്റ്റിനേഷൻ ഫയൽ ബൈനറി റൈറ്റ് മോഡിൽ (`"wb+"`) തുറക്കുന്നു.
• നമ്മൾ await file.read() ഉപയോഗിച്ച് അപ്‌ലോഡ് ചെയ്ത ഫയലിൻ്റെ ഉള്ളടക്കം അസിൻക്രണസ് ആയി വായിക്കുകയും തുടർന്ന് അത് ലോക്കൽ ഫയലിലേക്ക് എഴുതുകയും ചെയ്യുന്നു.

കുറിപ്പ്: വളരെ വലിയ ഫയലുകൾക്ക് await file.read() ഉപയോഗിച്ച് മുഴുവൻ ഫയലും മെമ്മറിയിലേക്ക് വായിക്കുന്നത് പ്രശ്‌നമുണ്ടാക്കിയേക്കാം. അത്തരം സാഹചര്യങ്ങളിൽ, ഫയൽ ഉള്ളടക്കം സ്ട്രീം ചെയ്യുന്നത് പരിഗണിക്കുക.

ഫയൽ ഉള്ളടക്കം സ്ട്രീം ചെയ്യുന്നു

വലിയ ഫയലുകൾക്കായി, മുഴുവൻ ഉള്ളടക്കവും മെമ്മറിയിലേക്ക് വായിക്കുന്നത് അമിതമായ മെമ്മറി ഉപയോഗത്തിനും ഔട്ട്-ഓഫ്-മെമ്മറി പിശകുകൾക്കും ഇടയാക്കും. ഫയൽ ഓരോ ചങ്കുകളായി സ്ട്രീം ചെയ്യുക എന്നതാണ് കൂടുതൽ മെമ്മറി-കാര്യക്ഷമമായ ഒരു സമീപനം. ഇതിനായി shutil.copyfileobj ഫംഗ്ഷൻ മികച്ചതാണ്, എന്നാൽ അസിൻക്രണസ് പ്രവർത്തനങ്ങൾക്കായി നമ്മൾ അതിനെ പൊരുത്തപ്പെടുത്തേണ്ടതുണ്ട്.

            from fastapi import FastAPI, File, UploadFile
import aiofiles # Install using: pip install aiofiles

app = FastAPI()

@app.post("/files/stream/")
async def stream_file(file: UploadFile = File(...)):
    file_location = f"./uploads/{file.filename}"
    async with aiofiles.open(file_location, "wb") as out_file:
        content = await file.read()
        await out_file.write(content)
    return {"info": f"file '{file.filename}' streamed and saved at '{file_location}'"}

            

              
                Copy
              
            
          

aiofiles ഉപയോഗിച്ച്, മുഴുവൻ ഫയലും ഒരേ സമയം മെമ്മറിയിലേക്ക് ലോഡുചെയ്യാതെ തന്നെ അപ്‌ലോഡ് ചെയ്ത ഫയലിൻ്റെ ഉള്ളടക്കം ഒരു ഡെസ്റ്റിനേഷൻ ഫയലിലേക്ക് കാര്യക്ഷമമായി സ്ട്രീം ചെയ്യാൻ നമുക്ക് കഴിയും. ഈ സന്ദർഭത്തിൽ await file.read() ഇപ്പോഴും മുഴുവൻ ഫയലും വായിക്കുന്നു, പക്ഷേ aiofiles എഴുത്ത് കൂടുതൽ കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യുന്നു. UploadFile ഉപയോഗിച്ച് യഥാർത്ഥ ചങ്ക്-ബൈ-ചങ്ക് സ്ട്രീമിംഗിനായി, നിങ്ങൾ സാധാരണയായി await file.read(chunk_size) എന്നതിലൂടെ ഇറ്ററേറ്റ് ചെയ്യും, എന്നാൽ സേവ് ചെയ്യുന്നതിനുള്ള ഒരു സാധാരണവും പ്രകടനക്ഷമവുമായ പാറ്റേണാണ് aiofiles.open, await out_file.write(content).

ചങ്കിംഗ് ഉപയോഗിക്കുന്ന കൂടുതൽ വ്യക്തമായ ഒരു സ്ട്രീമിംഗ് സമീപനം:

            from fastapi import FastAPI, File, UploadFile
import aiofiles

app = FastAPI()

CHUNK_SIZE = 1024 * 1024 # 1MB chunk size

@app.post("/files/chunked_stream/")
async def chunked_stream_file(file: UploadFile = File(...)):
    file_location = f"./uploads/{file.filename}"
    async with aiofiles.open(file_location, "wb") as out_file:
        while content := await file.read(CHUNK_SIZE):
            await out_file.write(content)
    return {"info": f"file '{file.filename}' chunked streamed and saved at '{file_location}'"}

            

              
                Copy
              
            
          

ഈ `chunked_stream_file` എൻഡ്‌പോയിൻ്റ് 1MB ചങ്കുകളായി ഫയൽ വായിക്കുകയും ഓരോ ചങ്കും ഔട്ട്പുട്ട് ഫയലിലേക്ക് എഴുതുകയും ചെയ്യുന്നു. വളരെ വലിയ ഫയലുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഏറ്റവും മെമ്മറി-കാര്യക്ഷമമായ മാർഗ്ഗമാണിത്.

ഒന്നിലധികം ഫയൽ അപ്‌ലോഡുകൾ കൈകാര്യം ചെയ്യുന്നു

വെബ് ആപ്ലിക്കേഷനുകൾക്ക് പലപ്പോഴും ഉപയോക്താക്കൾ ഒരേസമയം ഒന്നിലധികം ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യേണ്ടതുണ്ട്. FastAPI ഇത് ലളിതമാക്കുന്നു.

ഫയലുകളുടെ ഒരു ലിസ്റ്റ് അപ്‌ലോഡ് ചെയ്യുന്നു

UploadFile-ൻ്റെ ഒരു ലിസ്റ്റ് ഉപയോഗിച്ച് നിങ്ങളുടെ പാരാമീറ്റർ അടയാളപ്പെടുത്തിക്കൊണ്ട് നിങ്ങൾക്ക് ഫയലുകളുടെ ഒരു ലിസ്റ്റ് സ്വീകരിക്കാൻ കഴിയും.

            from fastapi import FastAPI, File, UploadFile, Form
from typing import List

app = FastAPI()

@app.post("/files/multiple/")
async def create_multiple_files(
    files: List[UploadFile] = File(...)
):
    results = []
    for file in files:
        # Process each file, e.g., save it
        file_location = f"./uploads/{file.filename}"
        with open(file_location, "wb+") as file_object:
            file_object.write(await file.read())
        results.append({"filename": file.filename, "content_type": file.content_type, "saved_at": file_location})
    return {"files_processed": results}

            

              
                Copy
              
            
          

ഈ സാഹചര്യത്തിൽ, ക്ലയൻ്റ് ഒരേ ഫോം ഫീൽഡ് നാമത്തിൽ (ഉദാ. files) ഒന്നിലധികം ഭാഗങ്ങൾ അയയ്‌ക്കേണ്ടതുണ്ട്. FastAPI അവയെ UploadFile ഒബ്ജക്റ്റുകളുടെ ഒരു പൈത്തൺ ലിസ്റ്റിലേക്ക് ശേഖരിക്കും.

ഫയലുകളും മറ്റ് ഫോം ഡാറ്റയും കലർത്തുന്നു

ഫയൽ ഫീൽഡുകളും സാധാരണ ടെക്സ്റ്റ് ഫീൽഡുകളും അടങ്ങുന്ന ഫോമുകൾ ഉണ്ടാകുന്നത് സാധാരണമാണ്. ഫയലുകളല്ലാത്ത ഫോം ഫീൽഡുകൾക്കായി Form ഉപയോഗിച്ച്, സ്റ്റാൻഡേർഡ് ടൈപ്പ് അനോട്ടേഷനുകൾ ഉപയോഗിച്ച് മറ്റ് പാരാമീറ്ററുകൾ പ്രഖ്യാപിക്കാൻ നിങ്ങളെ അനുവദിച്ചുകൊണ്ട് FastAPI ഇത് കൈകാര്യം ചെയ്യുന്നു.

            from fastapi import FastAPI, File, UploadFile, Form
from typing import List

app = FastAPI()

@app.post("/files/mixed/")
async def upload_mixed_data(
    description: str = Form(...),
    files: List[UploadFile] = File(...) # Accepts multiple files with the name 'files'
):
    results = []
    for file in files:
        # Process each file
        file_location = f"./uploads/{file.filename}"
        with open(file_location, "wb+") as file_object:
            file_object.write(await file.read())
        results.append({"filename": file.filename, "content_type": file.content_type, "saved_at": file_location})
    return {
        "description": description,
        "files_processed": results
    }

            

              
                Copy
              
            
          

Swagger UI അല്ലെങ്കിൽ Postman പോലുള്ള ടൂളുകൾ ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾ description ഒരു സാധാരണ ഫോം ഫീൽഡായി വ്യക്തമാക്കുകയും തുടർന്ന് files ഫീൽഡിനായി ഒന്നിലധികം ഭാഗങ്ങൾ ചേർക്കുകയും ചെയ്യും, ഓരോന്നിൻ്റെയും ഉള്ളടക്ക തരം ഉചിതമായ ഇമേജ്/ഡോക്യുമെൻ്റ് തരത്തിലേക്ക് സജ്ജമാക്കും.

നൂതന ഫീച്ചറുകളും മികച്ച രീതികളും

അടിസ്ഥാന ഫയൽ കൈകാര്യം ചെയ്യലിനപ്പുറം, ശക്തമായ ഫയൽ അപ്‌ലോഡ് API-കൾ നിർമ്മിക്കുന്നതിന് നിരവധി നൂതന ഫീച്ചറുകളും മികച്ച രീതികളും നിർണായകമാണ്.

ഫയൽ വലുപ്പ പരിധികൾ

പരിധിയില്ലാത്ത ഫയൽ അപ്‌ലോഡുകൾ അനുവദിക്കുന്നത് ഡിനയൽ-ഓഫ്-സർവീസ് ആക്രമണങ്ങൾക്കോ അമിതമായ വിഭവ ഉപഭോഗത്തിനോ ഇടയാക്കും. FastAPI സ്വതവേ ഫ്രെയിംവർക്ക് തലത്തിൽ കർശനമായ പരിധികൾ നടപ്പിലാക്കുന്നില്ലെങ്കിലും, നിങ്ങൾ പരിശോധനകൾ നടപ്പിലാക്കണം:

• ആപ്ലിക്കേഷൻ തലത്തിൽ: ഫയൽ ലഭിച്ചതിന് ശേഷം എന്നാൽ പ്രോസസ്സ് ചെയ്യുകയോ സേവ് ചെയ്യുകയോ ചെയ്യുന്നതിന് മുമ്പ് ഫയൽ വലുപ്പം പരിശോധിക്കുക.
• വെബ് സെർവർ/പ്രോക്സി തലത്തിൽ: ഒരു നിശ്ചിത പേലോഡ് വലുപ്പത്തിൽ കൂടുതലുള്ള അഭ്യർത്ഥനകൾ നിരസിക്കാൻ നിങ്ങളുടെ വെബ് സെർവർ (ഉദാ., Nginx, Uvicorn with workers) കോൺഫിഗർ ചെയ്യുക.

ആപ്ലിക്കേഷൻ തലത്തിലുള്ള വലുപ്പ പരിശോധനയുടെ ഉദാഹരണം:

            from fastapi import FastAPI, File, UploadFile, HTTPException

app = FastAPI()

MAX_FILE_SIZE_MB = 10
MAX_FILE_SIZE_BYTES = MAX_FILE_SIZE_MB * 1024 * 1024

@app.post("/files/limited_size/")
async def upload_with_size_limit(file: UploadFile = File(...)):
    if len(await file.read()) > MAX_FILE_SIZE_BYTES:
        raise HTTPException(status_code=400, detail=f"File is too large. Maximum size is {MAX_FILE_SIZE_MB}MB.")
    
    # Reset file pointer to read content again
    await file.seek(0)
    
    # Proceed with saving or processing the file
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())
        
    return {"info": f"File '{file.filename}' uploaded successfully."}

            

              
                Copy
              
            
          

പ്രധാനപ്പെട്ടത്: ഫയലിൻ്റെ വലുപ്പം പരിശോധിക്കാൻ വായിച്ചതിനു ശേഷം, അതിൻ്റെ ഉള്ളടക്കം വീണ്ടും വായിക്കാൻ നിങ്ങൾ ഉദ്ദേശിക്കുന്നുവെങ്കിൽ (ഉദാഹരണത്തിന്, അത് സേവ് ചെയ്യാൻ), ഫയൽ പോയിൻ്റർ തുടക്കത്തിലേക്ക് പുനഃക്രമീകരിക്കുന്നതിന് നിങ്ങൾ await file.seek(0) ഉപയോഗിക്കണം.

അനുവദനീയമായ ഫയൽ തരങ്ങൾ (MIME തരങ്ങൾ)

നിർദ്ദിഷ്ട ഫയൽ തരങ്ങളിലേക്ക് അപ്‌ലോഡുകൾ പരിമിതപ്പെടുത്തുന്നത് സുരക്ഷ വർദ്ധിപ്പിക്കുകയും ഡാറ്റയുടെ സമഗ്രത ഉറപ്പാക്കുകയും ചെയ്യുന്നു. നിങ്ങൾക്ക് UploadFile ഒബ്ജക്റ്റിൻ്റെ content_type ആട്രിബ്യൂട്ട് പരിശോധിക്കാവുന്നതാണ്.

            from fastapi import FastAPI, File, UploadFile, HTTPException

app = FastAPI()

ALLOWED_FILE_TYPES = {"image/jpeg", "image/png", "application/pdf"}

@app.post("/files/restricted_types/")
async def upload_restricted_types(file: UploadFile = File(...)):
    if file.content_type not in ALLOWED_FILE_TYPES:
        raise HTTPException(status_code=400, detail=f"Unsupported file type: {file.content_type}. Allowed types are: {', '.join(ALLOWED_FILE_TYPES)}")
        
    # Proceed with saving or processing the file
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())
        
    return {"info": f"File '{file.filename}' uploaded successfully and is of an allowed type."}

            

              
                Copy
              
            
          

കൂടുതൽ ശക്തമായ ടൈപ്പ് പരിശോധനയ്ക്കായി, പ്രത്യേകിച്ച് ചിത്രങ്ങൾക്ക്, ഫയലിൻ്റെ യഥാർത്ഥ ഉള്ളടക്കം പരിശോധിക്കാൻ Pillow പോലുള്ള ലൈബ്രറികൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കാവുന്നതാണ്, കാരണം MIME തരങ്ങൾ ചിലപ്പോൾ കബളിപ്പിക്കപ്പെടാം.

പിശകുകൾ കൈകാര്യം ചെയ്യലും ഉപയോക്തൃ ഫീഡ്‌ബ্যাক

ഉപയോക്താവിന് വ്യക്തവും പ്രവർത്തനക്ഷമവുമായ പിശക് സന്ദേശങ്ങൾ നൽകുക. സ്റ്റാൻഡേർഡ് എച്ച്ടിടിപി പിശക് പ്രതികരണങ്ങൾക്കായി FastAPI-യുടെ HTTPException ഉപയോഗിക്കുക.

• ഫയൽ കണ്ടെത്താനായില്ല/കാണാതായി: ആവശ്യമായ ഒരു ഫയൽ പാരാമീറ്റർ അയച്ചിട്ടില്ലെങ്കിൽ.
• ഫയൽ വലുപ്പം കവിഞ്ഞു: വലുപ്പ പരിധി ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ.
• അസാധുവായ ഫയൽ തരം: ടൈപ്പ് നിയന്ത്രണ ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ.
• സെർവർ പിശകുകൾ: ഫയൽ സേവ് ചെയ്യുമ്പോഴോ പ്രോസസ്സ് ചെയ്യുമ്പോഴോ ഉണ്ടാകുന്ന പ്രശ്നങ്ങൾക്ക് (ഉദാ. ഡിസ്ക് നിറഞ്ഞു, അനുമതി പിശകുകൾ).

സുരക്ഷാ പരിഗണനകൾ

ഫയൽ അപ്‌ലോഡുകൾ സുരക്ഷാ അപകടസാധ്യതകൾ സൃഷ്ടിക്കുന്നു:

• ക്ഷുദ്രകരമായ ഫയലുകൾ: എക്സിക്യൂട്ടബിൾ ഫയലുകൾ (.exe, .sh) അല്ലെങ്കിൽ മറ്റ് ഫയൽ തരങ്ങളായി വേഷംമാറിയ സ്ക്രിപ്റ്റുകൾ അപ്‌ലോഡ് ചെയ്യുന്നത്. എല്ലായ്പ്പോഴും ഫയൽ തരങ്ങൾ സാധൂകരിക്കുകയും അപ്‌ലോഡ് ചെയ്ത ഫയലുകൾ മാൽവെയറിനായി സ്കാൻ ചെയ്യുന്നത് പരിഗണിക്കുകയും ചെയ്യുക.
• പാത്ത് ട്രാവേഴ്സൽ: ഉദ്ദേശിക്കാത്ത ഡയറക്ടറികളിലേക്ക് ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യുന്നതിൽ നിന്ന് ആക്രമണകാരികളെ തടയുന്നതിന് ഫയൽനാമങ്ങൾ സാനിറ്റൈസ് ചെയ്യുക (ഉദാ., ../../etc/passwd പോലുള്ള ഫയൽനാമങ്ങൾ ഉപയോഗിക്കുന്നത്). FastAPI-യുടെ UploadFile അടിസ്ഥാന ഫയൽനാമം സാനിറ്റൈസേഷൻ കൈകാര്യം ചെയ്യുന്നു, പക്ഷേ അധിക ശ്രദ്ധ നല്ലതാണ്.
• ഡിനയൽ ഓഫ് സർവീസ്: ഫയൽ വലുപ്പ പരിധികളും അപ്‌ലോഡ് എൻഡ്‌പോയിൻ്റുകളിൽ റേറ്റ് ലിമിറ്റിംഗും നടപ്പിലാക്കുക.
• ക്രോസ്-സൈറ്റ് സ്ക്രിപ്റ്റിംഗ് (XSS): നിങ്ങൾ ഒരു വെബ് പേജിൽ ഫയൽനാമങ്ങളോ ഫയൽ ഉള്ളടക്കമോ നേരിട്ട് പ്രദർശിപ്പിക്കുകയാണെങ്കിൽ, XSS ആക്രമണങ്ങൾ തടയുന്നതിന് അവ ശരിയായി എസ്കേപ്പ് ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക.

മികച്ച രീതി: അപ്‌ലോഡ് ചെയ്ത ഫയലുകൾ നിങ്ങളുടെ വെബ് സെർവറിൻ്റെ ഡോക്യുമെൻ്റ് റൂട്ടിന് പുറത്ത് സൂക്ഷിക്കുക, അവയെ ഉചിതമായ ആക്‌സസ്സ് നിയന്ത്രണങ്ങളുള്ള ഒരു സമർപ്പിത എൻഡ്‌പോയിൻ്റിലൂടെ നൽകുക, അല്ലെങ്കിൽ ഒരു കണ്ടൻ്റ് ഡെലിവറി നെറ്റ്‌വർക്ക് (CDN) ഉപയോഗിക്കുക.

ഫയൽ അപ്‌ലോഡുകളോടൊപ്പം Pydantic മോഡലുകൾ ഉപയോഗിക്കുന്നു

ഫയലുകൾക്കായുള്ള പ്രാഥമിക തരം UploadFile ആണെങ്കിലും, കൂടുതൽ സങ്കീർണ്ണമായ ഡാറ്റാ ഘടനകൾക്കായി നിങ്ങൾക്ക് ഫയൽ അപ്‌ലോഡുകൾ Pydantic മോഡലുകളിലേക്ക് സംയോജിപ്പിക്കാൻ കഴിയും. എന്നിരുന്നാലും, സ്റ്റാൻഡേർഡ് Pydantic മോഡലുകൾക്കുള്ളിൽ നേരിട്ടുള്ള ഫയൽ അപ്‌ലോഡ് ഫീൽഡുകൾ മൾട്ടിപാർട്ട് ഫോമുകൾക്ക് സ്വാഭാവികമായി പിന്തുണയ്ക്കുന്നില്ല. പകരം, നിങ്ങൾ സാധാരണയായി ഫയൽ ഒരു പ്രത്യേക പാരാമീറ്ററായി സ്വീകരിക്കുകയും തുടർന്ന് ഒരു Pydantic മോഡലിന് സംഭരിക്കാനോ സാധൂകരിക്കാനോ കഴിയുന്ന ഒരു ഫോർമാറ്റിലേക്ക് പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു.

ഒരു സാധാരണ പാറ്റേൺ, മെറ്റാഡാറ്റയ്ക്കായി ഒരു Pydantic മോഡൽ ഉണ്ടായിരിക്കുകയും തുടർന്ന് ഫയൽ വെവ്വേറെ സ്വീകരിക്കുകയും ചെയ്യുക എന്നതാണ്:

            from fastapi import FastAPI, File, UploadFile, Form
from pydantic import BaseModel
from typing import Optional

class UploadMetadata(BaseModel):
    title: str
    description: Optional[str] = None

app = FastAPI()

@app.post("/files/model_metadata/")
async def upload_with_metadata(
    metadata: str = Form(...), # Receive metadata as a JSON string
    file: UploadFile = File(...)
):
    import json
    try:
        metadata_obj = UploadMetadata(**json.loads(metadata))
    except json.JSONDecodeError:
        raise HTTPException(status_code=400, detail="Invalid JSON format for metadata")
    except Exception as e:
        raise HTTPException(status_code=400, detail=f"Error parsing metadata: {e}")

    # Now you have metadata_obj and file
    # Proceed with saving file and using metadata
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())

    return {
        "message": "File uploaded successfully with metadata",
        "metadata": metadata_obj,
        "filename": file.filename
    }

            

              
                Copy
              
            
          

ഈ പാറ്റേണിൽ, ക്ലയൻ്റ് മെറ്റാഡാറ്റ ഒരു ഫോം ഫീൽഡിനുള്ളിൽ (ഉദാ. metadata) ഒരു JSON സ്ട്രിംഗായും ഫയൽ ഒരു പ്രത്യേക മൾട്ടിപാർട്ട് ഭാഗമായും അയയ്ക്കുന്നു. തുടർന്ന് സെർവർ JSON സ്ട്രിംഗ് ഒരു Pydantic ഒബ്ജക്റ്റിലേക്ക് പാഴ്സ് ചെയ്യുന്നു.

വലിയ ഫയൽ അപ്‌ലോഡുകളും ചങ്കിംഗും

വളരെ വലിയ ഫയലുകൾക്ക് (ഉദാഹരണത്തിന്, ജിഗാബൈറ്റുകൾ), സ്ട്രീമിംഗ് പോലും വെബ് സെർവർ അല്ലെങ്കിൽ ക്ലയൻ്റ്-സൈഡ് പരിമിതികളിൽ തട്ടിയേക്കാം. കൂടുതൽ നൂതനമായ ഒരു സാങ്കേതികതയാണ് ചങ്ക്ഡ് അപ്‌ലോഡുകൾ, ഇവിടെ ക്ലയൻ്റ് ഫയലിനെ ചെറിയ കഷണങ്ങളാക്കി വിഭജിച്ച് അവയെ തുടർച്ചയായോ സമാന്തരമായോ അപ്‌ലോഡ് ചെയ്യുന്നു. തുടർന്ന് സെർവർ ഈ ചങ്കുകൾ പുനഃസംയോജിപ്പിക്കുന്നു. ഇതിന് സാധാരണയായി കസ്റ്റം ക്ലയൻ്റ്-സൈഡ് ലോജിക്കും ചങ്ക് മാനേജ്‌മെൻ്റ് കൈകാര്യം ചെയ്യാൻ രൂപകൽപ്പന ചെയ്ത ഒരു സെർവർ എൻഡ്‌പോയിൻ്റും (ഉദാഹരണത്തിന്, ചങ്കുകൾ തിരിച്ചറിയൽ, താൽക്കാലിക സംഭരണം, അന്തിമ സംയോജനം) ആവശ്യമാണ്.

ക്ലയൻ്റ് ആരംഭിക്കുന്ന ചങ്ക്ഡ് അപ്‌ലോഡുകൾക്ക് FastAPI-യിൽ ബിൽറ്റ്-ഇൻ പിന്തുണ ഇല്ലെങ്കിലും, നിങ്ങളുടെ FastAPI എൻഡ്‌പോയിൻ്റുകൾക്കുള്ളിൽ ഈ ലോജിക് നടപ്പിലാക്കാൻ കഴിയും. ഇത് ഇനിപ്പറയുന്നവ ചെയ്യുന്ന എൻഡ്‌പോയിൻ്റുകൾ സൃഷ്ടിക്കുന്നതിൽ ഉൾപ്പെടുന്നു:

• വ്യക്തിഗത ഫയൽ ചങ്കുകൾ സ്വീകരിക്കുക.
• ഈ ചങ്കുകൾ താൽക്കാലികമായി സംഭരിക്കുക, ഒരുപക്ഷേ അവയുടെ ക്രമവും ചങ്കുകളുടെ എണ്ണവും സൂചിപ്പിക്കുന്ന മെറ്റാഡാറ്റ ഉപയോഗിച്ച്.
• എല്ലാ ചങ്കുകളും അപ്‌ലോഡ് ചെയ്തുകഴിഞ്ഞാൽ സൂചന നൽകുന്നതിനായി ഒരു എൻഡ്‌പോയിൻ്റോ മെക്കാനിസമോ നൽകുക, ഇത് പുനഃസംയോജന പ്രക്രിയയെ പ്രവർത്തനക്ഷമമാക്കുന്നു.

ഇത് കൂടുതൽ സങ്കീർണ്ണമായ ഒരു സംരംഭമാണ്, പലപ്പോഴും ക്ലയൻ്റ് ഭാഗത്ത് ജാവാസ്ക്രിപ്റ്റ് ലൈബ്രറികൾ ഉൾപ്പെടുന്നു.

അന്താരാഷ്ട്രവൽക്കരണവും ആഗോളവൽക്കരണവും സംബന്ധിച്ച പരിഗണനകൾ

ഒരു ആഗോള പ്രേക്ഷകർക്കായി API-കൾ നിർമ്മിക്കുമ്പോൾ, ഫയൽ അപ്‌ലോഡുകൾക്ക് പ്രത്യേക ശ്രദ്ധ ആവശ്യമാണ്:

• ഫയൽനാമങ്ങൾ: ലോകമെമ്പാടുമുള്ള ഉപയോക്താക്കൾ ഫയൽനാമങ്ങളിൽ ASCII ഇതര പ്രതീകങ്ങൾ (ഉദാഹരണത്തിന്, ആക്‌സൻ്റുകൾ, ഐഡിയോഗ്രാമുകൾ) ഉപയോഗിച്ചേക്കാം. നിങ്ങളുടെ സിസ്റ്റം ഈ ഫയൽനാമങ്ങൾ ശരിയായി കൈകാര്യം ചെയ്യുകയും സംഭരിക്കുകയും ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുക. UTF-8 എൻകോഡിംഗ് സാധാരണയായി സ്റ്റാൻഡേർഡാണ്, എന്നാൽ ആഴത്തിലുള്ള അനുയോജ്യതയ്ക്ക് ശ്രദ്ധാപൂർവ്വമായ എൻകോഡിംഗ്/ഡീകോഡിംഗ്, സാനിറ്റൈസേഷൻ എന്നിവ ആവശ്യമായി വന്നേക്കാം.
• ഫയൽ വലുപ്പ യൂണിറ്റുകൾ: MB, GB എന്നിവ സാധാരണമാണെങ്കിലും, ഉപയോക്താക്കൾ ഫയൽ വലുപ്പങ്ങളെ എങ്ങനെ കാണുന്നു എന്നതിനെക്കുറിച്ച് ശ്രദ്ധിക്കുക. ഉപയോക്തൃ-സൗഹൃദപരമായ രീതിയിൽ പരിധികൾ പ്രദർശിപ്പിക്കുന്നത് പ്രധാനമാണ്.
• ഉള്ളടക്ക തരങ്ങൾ: ഉപയോക്താക്കൾ സാധാരണയല്ലാത്ത MIME തരങ്ങളുള്ള ഫയലുകൾ അപ്‌ലോഡ് ചെയ്തേക്കാം. നിങ്ങളുടെ അനുവദനീയമായ തരങ്ങളുടെ ലിസ്റ്റ് നിങ്ങളുടെ ഉപയോഗത്തിന് സമഗ്രമോ വഴക്കമുള്ളതോ ആണെന്ന് ഉറപ്പാക്കുക.
• പ്രാദേശിക നിയന്ത്രണങ്ങൾ: വിവിധ രാജ്യങ്ങളിലെ ഡാറ്റാ റെസിഡൻസി നിയമങ്ങളെയും നിയന്ത്രണങ്ങളെയും കുറിച്ച് ബോധവാന്മാരായിരിക്കുക. അപ്‌ലോഡ് ചെയ്ത ഫയലുകൾ സംഭരിക്കുന്നതിന് ഈ നിയമങ്ങൾ പാലിക്കേണ്ടി വന്നേക്കാം.
• ഉപയോക്തൃ ഇൻ്റർഫേസ്: ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യുന്നതിനുള്ള ക്ലയൻ്റ്-സൈഡ് ഇൻ്റർഫേസ് ഉപയോക്താവിൻ്റെ ഭാഷയെയും ലൊക്കേലിനെയും പിന്തുണയ്ക്കുന്നതും അവബോധജന്യവുമായിരിക്കണം.

പരിശോധിക്കുന്നതിനുള്ള ടൂളുകളും ലൈബ്രറികളും

ഫയൽ അപ്‌ലോഡ് എൻഡ്‌പോയിൻ്റുകൾ പരിശോധിക്കുന്നത് നിർണായകമാണ്. സാധാരണയായി ഉപയോഗിക്കുന്ന ചില ടൂളുകൾ ഇതാ:

• Swagger UI (ഇൻ്ററാക്ടീവ് എപിഐ ഡോക്‌സ്): FastAPI യാന്ത്രികമായി Swagger UI ഡോക്യുമെൻ്റേഷൻ സൃഷ്ടിക്കുന്നു. നിങ്ങൾക്ക് ബ്രൗസർ ഇൻ്റർഫേസിൽ നിന്ന് നേരിട്ട് ഫയൽ അപ്‌ലോഡുകൾ പരീക്ഷിക്കാൻ കഴിയും. ഫയൽ ഇൻപുട്ട് ഫീൽഡിനായി നോക്കി "Choose File" ബട്ടണിൽ ക്ലിക്കുചെയ്യുക.
• Postman: ഒരു ജനപ്രിയ API ഡെവലപ്‌മെൻ്റ്, ടെസ്റ്റിംഗ് ടൂൾ. ഒരു ഫയൽ അപ്‌ലോഡ് അഭ്യർത്ഥന അയയ്‌ക്കുന്നതിന്:
• അഭ്യർത്ഥന രീതി POST ആയി സജ്ജമാക്കുക.
• നിങ്ങളുടെ API എൻഡ്‌പോയിൻ്റ് URL നൽകുക.
• "Body" ടാബിലേക്ക് പോകുക.
• തരം "form-data" ആയി തിരഞ്ഞെടുക്കുക.
• കീ-വാല്യൂ ജോഡികളിൽ, നിങ്ങളുടെ ഫയൽ പാരാമീറ്ററിൻ്റെ പേര് നൽകുക (ഉദാഹരണത്തിന്, file).
• തരം "Text" എന്നതിൽ നിന്ന് "File" എന്നതിലേക്ക് മാറ്റുക.
• നിങ്ങളുടെ ലോക്കൽ സിസ്റ്റത്തിൽ നിന്ന് ഒരു ഫയൽ തിരഞ്ഞെടുക്കാൻ "Choose Files" ക്ലിക്കുചെയ്യുക.
• നിങ്ങൾക്ക് മറ്റ് ഫോം ഫീൽഡുകളുണ്ടെങ്കിൽ, അവയുടെ തരം "Text" ആയി നിലനിർത്തിക്കൊണ്ട് സമാനമായി ചേർക്കുക.
• അഭ്യർത്ഥന അയയ്ക്കുക.
• cURL: എച്ച്ടിടിപി അഭ്യർത്ഥനകൾ നടത്തുന്നതിനുള്ള ഒരു കമാൻഡ്-ലൈൻ ഉപകരണം.
• ഒരൊറ്റ ഫയലിനായി: curl -X POST -F "file=@/path/to/your/local/file.txt" http://localhost:8000/files/
• ഒന്നിലധികം ഫയലുകൾക്കായി: curl -X POST -F "files=@/path/to/file1.txt" -F "files=@/path/to/file2.png" http://localhost:8000/files/multiple/
• മിക്സഡ് ഡാറ്റയ്ക്കായി: curl -X POST -F "description=My description" -F "files=@/path/to/file.txt" http://localhost:8000/files/mixed/
• പൈത്തണിൻ്റെ `requests` ലൈബ്രറി: പ്രോഗ്രാമാറ്റിക് ടെസ്റ്റിംഗിനായി.

            import requests

url = "http://localhost:8000/files/save/"
files = {'file': open('/path/to/your/local/file.txt', 'rb')}

response = requests.post(url, files=files)
print(response.json())

# For multiple files
url_multiple = "http://localhost:8000/files/multiple/"
files_multiple = {
    'files': [('file1.txt', open('/path/to/file1.txt', 'rb')),
              ('image.png', open('/path/to/image.png', 'rb'))]
}
response_multiple = requests.post(url_multiple, files=files_multiple)
print(response_multiple.json())

# For mixed data
url_mixed = "http://localhost:8000/files/mixed/"
data = {'description': 'Test description'}
files_mixed = {'files': open('/path/to/another_file.txt', 'rb')}
response_mixed = requests.post(url_mixed, data=data, files=files_mixed)
print(response_mixed.json())

            

              
                Copy
              
            
          

ഉപസംഹാരം

FastAPI മൾട്ടിപാർട്ട് ഫയൽ അപ്‌ലോഡുകൾ കൈകാര്യം ചെയ്യുന്നതിന് ശക്തവും കാര്യക്ഷമവും അവബോധജന്യവുമായ ഒരു മാർഗ്ഗം നൽകുന്നു. UploadFile തരവും അസിൻക്രണസ് പ്രോഗ്രാമിംഗും പ്രയോജനപ്പെടുത്തുന്നതിലൂടെ, ഡെവലപ്പർമാർക്ക് ഫയൽ കൈകാര്യം ചെയ്യൽ കഴിവുകൾ പരിധികളില്ലാതെ സംയോജിപ്പിക്കുന്ന ശക്തമായ API-കൾ നിർമ്മിക്കാൻ കഴിയും. സുരക്ഷയ്ക്ക് മുൻഗണന നൽകാനും ഉചിതമായ പിശക് കൈകാര്യം ചെയ്യൽ നടപ്പിലാക്കാനും ഫയൽനാമം എൻകോഡിംഗ്, നിയന്ത്രണ വിധേയത്വം തുടങ്ങിയ വശങ്ങൾ പരിഹരിച്ച് ഒരു ആഗോള ഉപയോക്തൃ അടിത്തറയുടെ ആവശ്യങ്ങൾ പരിഗണിക്കാനും ഓർമ്മിക്കുക.

നിങ്ങൾ ഒരു ലളിതമായ ഇമേജ് ഷെയറിംഗ് സേവനം നിർമ്മിക്കുകയാണെങ്കിലും അല്ലെങ്കിൽ സങ്കീർണ്ണമായ ഒരു ഡോക്യുമെൻ്റ് പ്രോസസ്സിംഗ് പ്ലാറ്റ്ഫോം നിർമ്മിക്കുകയാണെങ്കിലും, FastAPI-യുടെ ഫയൽ അപ്‌ലോഡ് സവിശേഷതകളിൽ വൈദഗ്ദ്ധ്യം നേടുന്നത് ഒരു പ്രധാന നേട്ടമായിരിക്കും. അതിൻ്റെ കഴിവുകൾ പര്യവേക്ഷണം ചെയ്യുന്നത് തുടരുക, മികച്ച രീതികൾ നടപ്പിലാക്കുക, നിങ്ങളുടെ അന്താരാഷ്ട്ര പ്രേക്ഷകർക്ക് അസാധാരണമായ ഉപയോക്തൃ അനുഭവങ്ങൾ നൽകുക.