Django రెండు రకాల ఫైల్లను వేరు చేస్తుంది: static files (మీ అప్లికేషన్లో భాగమైన assets — CSS, JavaScript, మీరు పంపిన images) మరియు media files (రన్టైమ్లో ఉపయోగకర్తలచే అప్లోడ్ చేయబడిన ఫైల్లు — ప్రొఫైల్ చిత్రాలు, డాక్యుమెంట్లు). ఇవి భిన్నంగా నిర్వహించబడతాయి ఎందుకంటే వాటి సోర్సులు మరియు జీవన చక్రాలు ప్రాథమికంగా భిన్నంగా ఉన్నాయి.
STATIC_URL =
STATICFILES_DIRS = [BASE_DIR / ]
STATIC_ROOT = BASE_DIR /
<!-- in templates -->
{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">
<img src="{% static 'images/logo.png' %}">
Static files మీ codebase లో భాగం — CSS, JS, fonts, డిజైన్ images. ఇవి version-controlled, అన్ని ఉపయోగకర్తలకు సమానంగా ఉంటాయి, మరియు మీ ప్రాజెక్ట్లోని static directories నుండి సేవ చేయబడతాయి.
python manage.py collectstatic
# gathers ALL static files (from your apps and STATICFILES_DIRS) into STATIC_ROOT,
# so a web server / CDN can serve them efficiently in production
ఉత్పత్తిలో, collectstatic అన్ని apps నుండి static filesలను ఒక డైరెక్టరీ (STATIC_ROOT) లోకి consolidates చేస్తుంది తద్వారా web server లేదా CDN సేవ చేయగలదు — Django ఉత్పత్తిలో వాటిని సేవ చేయదు.
# settings.py
MEDIA_URL = "/media/"
MEDIA_ROOT = BASE_DIR / "media" # where UPLOADED files are stored
# a model with an uploadable file
class Profile(models.Model):
avatar = models.ImageField(upload_to="avatars/") # stored under MEDIA_ROOT/avatars/
document = models.FileField(upload_to="docs/")
profile.avatar.url # the URL to access the uploaded file
Media files రన్టైమ్లో ఉపయోగకర్తలచే అప్లోడ్ చేయబడతాయి FileField/ImageField ద్వారా. ఇవి dynamic, version control లో లేవు, మరియు ఉపయోగకర్తలు కంటెంట్ను అప్లోడ్ చేయడంతో సమయానికి సమయానికి పెరుగుతాయి.
Static files Media files
Source part of your code uploaded by users at runtime
Version control YES (committed) NO (user-generated, .gitignored)
Lifecycle fixed (changes with code) dynamic (grows continuously)
Examples CSS, JS, logos, fonts avatars, uploaded documents, photos
Settings STATIC_URL/ROOT/DIRS MEDIA_URL/ROOT
Production collectstatic + CDN/server stored on disk/cloud (S3), served carefully
✓ Static → serve via the web server (nginx) or a CDN (cached, fast)
✓ Media → store on cloud storage (S3) for scalability/persistence; in multi-server
setups, local disk doesn't work (files must be shared) → use S3/object storage
✓ Security → VALIDATE uploaded files (type, size); be careful serving user uploads
(a user could upload malicious content)
static-vs-media వేరుచేయడం Django అప్లికేషన్లను సరిగ్గా నిర్మించడం మరియు సరిగ్గా కాపీ చేయడం రెండింటికీ ముఖ్యమైనది, ఎందుకంటే రెండు ఫైల్ రకాలకు ప్రాథమికంగా భిన్నమైన sources, lifecycles, మరియు handling requirements ఉన్నాయి. Static files (మీ అప్లికేషన్లోని స్వంత CSS, JavaScript, images, fonts) codebase లో భాగం, version-controlled, మరియు ప్రతిఒక్కరికీ సమానం — {% static %} ద్వారా సూచించబడతాయి మరియు collectstatic ఉపయోగించి web server లేదా CDN ద్వారా ఉత్పత్తిలో సేవ చేయడానికి consolidated. Media files (FileField/ImageField ద్వారా ఉపయోగకర్త uploads) dynamic, user-generated content రన్టైమ్లో సృష్టించబడతాయి, version control లో లేవు, మరియు నిరంతరం పెరుగుతూ ఉంటాయి.
వాటిని గందరగోళానికి గురిచేయడం లేదా వాటి settings (STATIC_* vs MEDIA_*) ను తప్పుగా కాన్ఫిగర్ చేయడం "my CSS isn't loading" లేదా "uploads don't work" సమస్యల యొక్క సాధారణ కారణం, ముఖ్యంగా ఉత్పత్తిలో Django static filesను సేవ చేయనప్పుడు (collectstatic మరియు సరిగ్గా server/CDN అవసరం).
వేరుచేయడం కూడా ముఖ్యమైన production మరియు security implications ఉంది: multi-server deploymentsలో media files స్థానిక disk పై ఆధారపడలేవు (అవి S3 వంటి shared cloud storage ను ఉపయోగించాలి), మరియు ఉపయోగకర్త uploadsకు validation (file type, size) మరియు malicious content నుండి security risksను నివారించడానికి జాగ్రత్తపూర్వక serving అవసరం.
రెండు రకాలను ఎలా కాన్ఫిగర్ మరియు నిర్వహించాలో, collectstatic యొక్క పాత్ర, మరియు ఉత్పత్తి విచారణలను (static కోసం CDN, media కోసం cloud storage, upload security) తెలుసుకోవడం ఆచరణాత్మక, తరచుగా-అవసరమైన జ్ఞానం Django అప్లికేషన్లను సరిగ్గా నిర్మించడం మరియు కాపీ చేయడం కోసం — సాధారణ stumbling block ఇది ఈ జ్ఞానం పరిష్కరిస్తుంది.