ניהול קבצים סטטיים בדג'נגו: מדריך מקיף

מדריכים
Django Python

בדרכה זו, נבחן מהם קבצים סטטיים בדג'נגו, היתרונות של ניהולם ביעילות, תפקידם ביישומי אינטרנט, ונקיים פרויקט דמו כדי להמחיש כיצד לנהל ולשרת קבצים סטטיים באמצעות שיטות וכלים שונים.

Table of Contents

Django היא פרויקט שפת Python ברמה גבוהה המספק למפתחים ברשת כלים עוצמתיים ליצירת יישומים ברשת במהירות וביעילות.

בעוד ש-Django מצוין ליצירת יישומי אינטרנט במהירות וביעילות, חשוב מאוד גם לדאוג למראה ולתחושה של היישומים האינטרנטיים שאתה מפתח. כדי לעשות זאת, עליך ללמוד איך לנהל את הנתונים שמספקים ומשקפים את המראה והתחושה של היישומים שלך.

קבצים סטטיים ב-Django

ב-Django, קבצים סטטיים הם הקבצים המשודרים ישירות ללקוח ללא עיבוד על ידי השרת.

בדרך כלל זה כולל CSS, קבצי JavaScript, תמונות, אייקונים, פונטים ונתונים אחרים הדרושים למראה ולתחושה של היישום האינטרנטי שלך.

Django מספק מנגנונים לניהול ולשירות קבצים סטטיים ביעילות, ובכך מבטיח חוויה משתמשים חלקה.

ניהול קבצים סטטיים ביעילות

כדי להבטיח שלמשתמשים של היישום האינטרנטי שלך תהיה חוויה משתמש טובה ושהיישום יתנהג כצפוי, עליך לנהל את הקבצים הסטטיים ביעילות.

ארגון וקישוט קבצים סטטיים נכון יבטיח טווחי טעינה דף מהירים, ושהעיבוריות תשתפר, ובכך ישפר את הסיפוק הכולל של המשתמשים.

Django מציע כלים ומוסכמות שונים לעזור בטיפול בקבצים סטטיים.

תפקיד הקבצים הסטטיים ביישומי אינטרנט

קבצים סטטיים הם חשובים מאוד, מאחר והם מגדירים איך יישום אינטרנט נראה ומרגיש. הם מגדירים איך רכיבים ביישום מעוצבים, איך הם מתנהגים בתגובה לאינטראקציות משתמש, ובסופו של דבר איך משתמש רואה כשהוא מבקר ביישום אינטרנט מסוים.

כשאתה משרת קבצים סטטיים ביעילות, תוכל ליצור ממשק משתמש מרהיב ומגיב, מה שמקנה ליישום יותר מעורר עניין וידידותי למשתמש.

הכנת פרויקט דמו

כדי להמחיש את המושגים של ניהול קבצים סטטיים בדגנו, נקיים פרויקט דמו מאפס.

פרויקט זה יכלל יצירת פרויקט דגנו, הגדרת הגדרות קבצים סטטיים ושילוב קבצים סטטיים ביישום רשת פשוט.

בכך שתלווה את הפרויקט הדמו, תרכוש ניסיון ידני בניהול קבצים סטטיים בדגנו ותבין את החשיבות שלהם בפיתוח אינטרנט.

למטרות הדרכה זו, נוצר דף תחילה כך שכשהמשתמשים יבקרו בדף הבית של הפרויקט שלנו, הם יראו כותרת מעוצבת המברכת אותם לאתר. זה גם יציג את תאריך היום באמצעות JavaScript, וכן נשרת תמונה לשלמת הדף.

יצירת תיקייה לאחסון הפרויקט

נתחיל ביצירת תיקייה שתשמש לאחסון הפרויקט הדמו באמצעות הפקודה הבאה:

mkdir sitepoint_django_static_tut

יצירת סביבת וירטואלית

מומלץ ליצור ולבודד פרויקטים חדשים בתוך סביבות וירטואליות. זה אומר שלכל פרויקט יהיה הסתייעות משלו מבלי להשפיע על ההתקנה הגלובלית של Python.

נשתמש בחבילה virtualenv כדי ליצור אותה. אם זה לא מותקן בסביבת הפיתוח שלך, התקן אותו באמצעות pip install virtualenv, וצור סביבת וירטואלית באמצעות הפקודה הבאה:

virtualenv myenv

הפקודה לעיל יוצרת סביבת וירטואלית בשם myenv. כדי להשתמש בסביבה הווירטואלית, עליך להפעיל אותה:

לינוקס/מעקינס:

. myenv/bin/activate

ונדוס:

. myenv\Scripts\activate

התקנת תלבושות

ברגע שהסביבה הווירטואלית פעילה, אפשר להתקין את התלבושות של הפרויקט שלך. כדי להתחיל, נתקין את Django. נתקין תלבושות נוספות כשנגיע לקטעים שמדגימים את שימוש בהן:

pip install Django

זה יתקין את הגרסה היציבה האחרונה של Django, שבזמנו של הכתיבה היא גרסה 5.0.

יצירת פרויקט Django

לאחר התקנת Django, יש לך גישה לפקודות ניהול Django. בואו נשתמש בהן כדי ליצור פרויקט Django בסביבה הווירטואלית:

django-admin startproject sitepoint_django .

הפקודה לעיל תיצור פרויקט Django בשם sitepoint_django והנקודה בסוף מעידה על כך שאנו רוצים ליצור את הפרויקט בספרייה הנוכחית.

יצירת אפליקציה דגמית

כדי להדגים את מסות המושגים של ניהול קבצי סטטי, עלינו ליצור לפחות אפליקציה אחת של Django בפרויקט שלנו:

python manage.py startapp  static_demo

זה יוצר אפליקציה חדשה בפרויקט שלנו בשם `static_demo`. כדי שהפרויקט שלנו יכיר בה, עלינו להוסיף אותה להגדרת האפליקציות המותקנות בקובץ `settings.py` של הפרויקט שלנו. פתח את `sitepoint_django/settings.py`, עבור אל ההגדרה `INSTALLED_APPS` והוסף `static_demo.apps.StaticDemoConfig` לתחתית הרשימה, כפי שמוצג להלן:

# sitepoint_django/settings.py

INSTALLED_APPS = [
    # אפליקציות אחרות
    'static_demo.apps.StaticDemoConfig',
]

יצירת תבנית הדף הראשי

נפרש כמה HTML כאשר המשתמש מבקר בדף הבית של האתר שלנו. באפליקציה `static_demo`, צור ספרייה בשם `templates`, ובתוכה צור ספרייה נוספת ות名叫ה `static_demo`. בספרייה זו, צור תבנית ות名叫ה `index.html` כך שהנתיב יהיה `static_demo/templates/static_demo/index.html`.

הכנס את הקוד הבא לתוך `index.html`:

<!-- static_demo/index.html -->

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Sitepoint Django Tutorial</title>
</head>
<body>
    <h2>Hello there, welcome to our great site!</h2>
</body>
</html>

יצירת התצוגה לדף הראשי

כדי שהתבנית תוצג למשתמשים בכל פעם שהם מבקרים בדף הבית של האפליקציה שלנו, אנו צריכים ליצור פונקציית תצוגה שתופעל להצגת התבנית `home.html`. פתח את הקובץ `static_demo/views.py` והכנס את הקוד הבא:

# static_demo/views.py

from django.shortcuts import render

def index(request):
    return render(request, "static_demo/home.html")

יצירת קובץ URL עבור static_demo

אנו רוצים שנוף האינדקס ביישום static_demo יפרסם את דף הבית בכל פעם שמשתמש מבקר באתר שלנו. לכן ניצור תכנית URL עבור פונקציית הנוף שתפרסם את דף הבית. לשם כך, עלינו ליצור קובץ urls.py עבור היישום static_demo, ואז לחבר את קובץ URL של static_demo לקובץ URL של הפרויקט.

לכן, ביישום static_demo, צור קובץ וקרא לו urls.py והוסף את הקוד הבא לתוכו:

# static_demo/urls.py

from django.urls import path
from .import views

app_name = 'static_demo'

urlpatterns = [
    path('', views.index, name="index"),
]

הקוד לעיל יוצר URL עבור נוף האינדקס של הפרויקט שלנו, כך שאם משתמש מבקר במשהו כמו http://oursite.com/, או אם אתה מבקר ב http://127.0.0.1:8000 בשלב הפיתוח, נוף האינדקס ייקרא כדי להגיב לכך.

בואו נוסיף את זה לקובץ URL של הפרויקט. פתח את הקובץ sitepoint_django/urls.py והוסף את הקוד הבא:

# sitepoint_django/urls.py

from django.contrib import admin
from django.urls import path, include # הוסף היכנסות ל-include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('static_demo.urls')), # הוסף את השורה הזו
]

הקוד לעיל מבצע כמה שינויים בקובץ urls.py הברירת מחדל. הוספנו היכנסות לפונקצית include, שאומרת לדפנו שאנו כוללים את static_demo.urls.

בדיקת הפרויקט

ההגדרה הראשונית של הפרויקט נעשתה עד כה. בואו נפעיל את שרת הפיתוח כדי לבדוק אם הכל מחובר היטב.

הפעל את הפרויקט עם הפקודה הבאה:

python manage.py runserver

אם הכל מוגדר נכון, אתה צריך להיות מסוגל לבקר ב-http://127.0.0.1:8000. תראה קצת טקסט לא מעוצב שמברך אותך על כניסתך לאתר.

שירות קבצים סטטיים בפיתוח

כדי להוסיף עיצוב לדף, JavaScript לתאריך, ואת התמונה, אנו צריכים לבצע שינויים בפרויקט. בואו נעשה זאת בהדרגה ונראה איך אנו יכולים לשרת את הקבצים הסטטיים השונים בדרכים שונות, מתחילים בסביבת הפיתוח.

הקמת ספרייה לקבצים סטטיים

Django ממליצה שכל הנתונים הסטטיים יהיו מנוהלים על פי יישום: כלומר, כל ה-CSS, JS והתמונות שצריך יישום מסוים צריכים להיות ממוקמים במרחב של אותו יישום. אז בואו נעדכן את היישום static_demo וניצור ספרייה בשם static, ובתוכה ניצור עוד ספרייה בשם static_demo. לאחר מכן, בתוך הספרייה static_demo נוצרים שלושה ספריות נוספות: css, js, ו-images. בסוף, יהיה לנו מבנה הדומה למה שמתחת:

static_demo/
    └── static/
        └── static_demo/
            ├── css/
            ├── js/
            └── images/

הסיבה לכך שתרצה ליצור ספרייה static_demo בתוך הספרייה static היא כדי לעזור לך לשמות את הנתונים הסטטיים שלך. אם יש לך יותר מיישום אחד, ויש לך את ה-CSS בשני היישומים שנקראים styles.css, Django יעבוד רק עם החוברת הראשונה שהוא מוצא, מאחר ולא יהיה מסוגל להבדיל בין האחרים. לכן, אנו משמים אותם כך ש-Django יוכל לדעת איזה קובץ נתון אנו מתייחסים אליו בתבניות שלנו.

יצירת הקבצים הסטטיים

בשלב זה, בואו רק נקבע נכסים סטטיים מינימליים שידגימו איך ניתן לשרת את הקבצים בשלב הפיתוח.

במדריך js, צור קובץ וקרא לו todays_date.js, והוסף את הקוד הבא:

/* static_demo/js/todays_date.js */

let formattedDate = new Date().toLocaleDateString();

document.getElementById('todaysDate').innerText = `The date today is ${formattedDate}`;

הקוד לעיל מקבל את תאריך היום מ-JavaScript, מעצב אותו כמחרוזת, ואז מציג אותו בתיבה עם מזהה todaysDate.

במדריך css, צור קובץ, קרא לו styles.css, והוסף את הקוד הבא:

/* static_demo/css/styles.css */

body {
    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: center;
    margin: 0;
}

h2 {
    font-size: 24px; 
    color: green;
}

הקוד לעיל משתמש בפריסת Flexbox כדי למרכז את כל הפריטים בדף גם אופקית וגם אנכית. הוא גם קובע את גודל פונט ה-H2 ל-24px ואת צבעו לירוק.

בנוגע לתמונה, אפשר להשתמש בכל תמונה שלך. פשוט העתק תמונה כלשהי לתיקייה images ושים לב לשם הקובץ.

הגדרת הגדרות קבצים סטטיים

כדי לשרת קבצים סטטיים בשלב הפיתוח, יש להגדיר מספר דברים בקובץ settings.py של Django. פתח את הקובץ sitepoint_django/settings.py ובדוק אם יש לך את ההגדרות הבאות:

# sitepoint_django/settings.py`

DEBUG=True

בפיתוח, מומלץ בדרך כלל להגדיר DEBUG על True בהגדרות של הפרויקט שלך ב-Django. קביעה זו מאפשרת תכונות בדיקה רבות, כולל הודעות שגיאה מפורטות וענפי עץ כיפוף, שהן חסרות תקדים לאבחון ולתיקון בעיות במהלך הפיתוח.

כמו כן, כשDEBUG מוגדר על True, יישום django.contrib.staticfiles מספק אוטומטית קבצים סטטיים מספרייה סטטית של כל יישום. ההתנהגות הזו מקלה על תהליך הפיתוח על ידי הפחתת הצורך בהגדרה ידנית לכל קבצי הסטטיק.

בהגדרת INSTALLED_APPS, בדוק האם הוספת את django.contrib.staticfiles. אם לא, הוסף אותו למעלה מהאפליקציות שיש לך בפרויקט. לדוגמא, בפרויקט זה הוסף אותו למעלה ממחרוזת ה-static_demo כפי שמוצג להלן:

# sitepoint_django/settings.py`

INSTALLED_APPS = [

    'django.contrib.staticfiles',
    'static_demo.apps.StaticDemoConfig',
]

יישום django.contrib.staticfiles שמספק דגמון הוא חיוני למיקור קבצים סטטיים במהלך הפיתוח. כברירת מחדל, הוא עובר על היישומים של הפרויקט שלך כדי לאתר ספריות קבצים סטטיים בתוך כל יישום. עם זאת, אם יש לך נכסים סטטיים נוספים שאינם קשורים לישום מסוים, עדיין תוכל לגרום להם להיות נגישים ל-django.contrib.staticfiles על ידי הגדרת הגדרת STATICFILES_DIRS בקובץ settings.py של הפרויקט שלך. קביעה זו מאפשרת לך לציין ספריות נוספות שבהן נמצאים קבצים סטטיים. לדוגמא:

# sitepoint_django/settings.py`

STATICFILES_DIRS = [
    "/dir/with/staticfiles/static",
    "/someother/dir/static",
    "/home/example.com/static",
]

בנוסף ל-DEBUG ו-STATICFILES_DIRS, עוד הגדרה חשובה ש�צריך לכלול בקובץ ההגדרות של הפרויקט שלך ב-Django היא STATIC_URL. בעוד ש-Django מספק ערך ברירת מחדל עבור STATIC_URL, אתה יכול להגדיר אותו באופן מפורש בקובץ settings.py שלך אם הוא כבר לא קיים.

ההגדרה STATIC_URL מציינת את כתובת ה-URL הבסיסית ממנה יוגש צירופי הנתונים הסטטיים. לדוגמה, הגדרה STATIC_URL = "static/" מורה ל-Django להגשת צירופי נתונים סטטיים מהנתיב /static/. זה אומר שלמשל, הקובץ הסגנון שממוקם באפליקציה static_demo יהיה נגיש בכתובת URL כמו http://127.0.0.1:8000/static/static_demo/css/styles.css.

עדכון התבנית

לאחר ההגדרות, כדי להשתמש בקבצים הסטטיים בתבנית, אנו צריכים לעדכן אותה עם ה-HTML הבא:

<!-- static_demo/index.html -->

<!-- add static file handling functionality -->
{% load static %}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Sitepoint Django Tutorial</title>

    <!-- link to css  below -->
    <link rel="stylesheet" href="{% static 'static_demo/css/styles.css'%}"> 
</head>
<body>
    <h2>Hello there, welcome to our great site</h2>
    <p id="todaysDate"></p>
    <!-- link to image  below -->
    <img src="{% static 'static_demo/images/flowerImage.png' %}" alt="Flower Image"> 

    <!-- link to js  below -->
    <script src="{% static 'static_demo/js/todays_date.js' %}"></script>
</body>
</html>

עדכון התבנית מציג לנו תג חדש: {% load static %}. תג זה טוען את פונקציית טיפול בקבצים סטטיים המוצעת על ידי מנוע התבניות של Django. הכלאה של תג זה בקובץ תבנית של Django מאפשרת לנו להשתמש בתגים תבנית וספירים הקשורים לקבצים סטטיים.

לדוגמה, שימוש בו בתבנית שלנו מאפשר לנו להתייחס לקבצים סטטיים כמו תמונות, CSS ו-JS באלמנטים HTML. שימוש בו גם מאפשר לדגוג לייצר URL להתייחסות לנכסים סטטיים:

<link rel="stylesheet" href="{% static 'static_demo/css/styles.css'%}"> 

<img src="{% static 'static_demo/images/flowerImage.png' %}" alt="Flower Image"> 

<script src="{% static 'static_demo/js/todays_date.js' %}"></script>

עם ההגדרות ועדכון התבנית במקום, עלינו להפעיל את הפרויקט ולבדוק האם הקבצים מוקדפים בשלב הפיתוח. הפעל את הפרויקט באמצעות הפקודה הבאה:

python manage.py runserver

אם הכל מוגדר נכון, עלינו להתקיים שרת הפיתוח על http://127.0.0.1:8000. אם נבקר בקישור זה, עלינו לקבל דף הדומה לזה שמתחת.

להיות דמוי תמונה מראה שהקבצים הסטטיים פועלים נכון.

עליכם לשים לב שבפיתוח דגוג, כאשר DEBUG=True בהגדרות הפרויקט שלך, ו-django.contrib.staticfiles מופעל, זה מאפשר לשרת הפיתוח של דגוג (runserver) לשרת קבצים סטטיים. בתרחיש זה, כל שינויים שמופיעים בקבצים סטטיים, כגון CSS, JavaScript, או תמונות, מתגלים באופן אוטומטי ומופעלים על ידי דגוג. תהליך חלק זה מאוד מפשט את הפיתוח, שכן תוכלו לראות באופן מיידי את ההשפעות של השינויים שלכם מבלי שתצטרכו לרענן באופן ידני או להפעיל מחדש את השרת.

אולם, בסביבות ייצור, שירות קבצים סטטיים בדרך כלל כרוך בשימוש בשרת רשת או CDN נפרד. במקרה זה, עידכונים בקבצים הסטטיים אולי לא יזוהים וייושמו אוטומטית על ידי Django, וזה דורש תערובת ידנית כדי להבטיח שהקבצים המעודכנים ישודרו למשתמשים. בנוסף, אם אתה בוחר לשדרג קבצים סטטיים באופן ידני בשיטה אחרת, כגון הנוף django.views.static.serve(), אולי לא יתרחש זיהוי ויישום אוטומטי של שינויים, ואולי תצטרך ליישם מנגנונים משלך לטפל בעידכוני קבצים סטטיים.

שירות קבצים סטטיים באמצעות WhiteNoise

בפיתוח, בעוד django.contrib.staticfiles מקל על התהליך של שירות נכסים סטטיים, מבטיח עדכון חלקלק כשאתה עושה שינויים.

עם זאת, כשמעבירים לייצור, הגדרות כמו DEBUG=True חייבות להיות משובשות, וקבצים סטטיים אולי ישודרו מ-CDN או משרת אחר. זה דורש פיתרון שמתאים גם לשתי הסביבות – מאפשר שירות חלקלק של קבצים במהלך הפיתוח בעוד משקף באופן מדויק את סביבת הייצור.

נכנס החבילה WhiteNoise. שמותחה להתאמה חלקלק עם Django, WhiteNoise מציעה פיתרון חזק לשירות קבצים סטטיים בשתי סביבות הפיתוח והייצור, ומספק גישה אחידה שמבטיחה עקביות ואמינות במהלך שלבי הפרויקטים. בואו נבחן את WhiteNoise.

התקנה והגדרת WhiteNoise ב-Django

התחל עם WhiteNoise היא פשוטה. בסעיף זה, נעבור על תהליך ההתקנה ונדרוש אותך איך להגדיר את WhiteNoise בתוכנית ה-Django שלך.

מתקינים את WhiteNoise כך:

pip install whitenoise

לאחר ההתקנה המוצלחת, עברו ל-sitepoint_django/settings.py, התפרסו למטה עד הסוף, ומצאו את ההגדרה STATIC_URL. מתחתיה, הוסיפו את ההגדרה STATIC_ROOT:

# sitepoint_django/settings.py

STATIC_ROOT = BASEDIR / "staticfiles"

ההגדרה לעיל אומרת לדגוגי שכאשר collectstatic מופעל, כל הנתונים הסטטיים בכל האפליקציות בפרויקט שלכם יאוספו וישמרו בספרייה הנקראת staticfiles.

הדבר הבא לעשות הוא להריץ את הפקודה הניהולית collectstatic:

python manage.py collectstatic

כדי לאפשר את WhiteNoise, עליכם להוסיף אותו לרשימת ההגדרות MIDDLEWARE, לערוך את קובץ settings.py, ולהוסיף את מידל ה-WhiteNoise אחרי SecurityMiddleware של דגוגי ולפני כל שאר המיידלים:

# sitepoint_django/settings.py

MIDDLEWARE = [
    # ...
    "django.middleware.security.SecurityMiddleware",
    "whitenoise.middleware.WhiteNoiseMiddleware",
    # ...
]

שימוש ב-WhiteNoise בפיתוח

עם הצעדים לעיל, WhiteNoise יכול לשמש אתכם בנתונים סטטיים בייצור. אך אם תרצו להריץ את הפרויקט בנקודה זו, שרת הפיתוח של דגוגי ייקח על עצמו את טיפול הקבצים הסטטיים באופן אוטומטי. אך כדי ליהנות מהתנהגות דומה בפיתוח ובייצור, זה רעיון טוב להשתמש בו גם לשירות קבצים בפיתוח.

כדי לעשות זאת, נבטל טיפול Django בקבצים הסטטיים ונאפשר ל-WhiteNoise להשתלט על ידי עריכת קובץ ההגדרות והוספת WhiteNoise לרשימת INSTALLED_APPS מעל django.contrib.staticfiles:

# sitepoint_django/settings.py

INSTALLED_APPS = [
    # ...
    "whitenoise.runserver_nostatic",
    "django.contrib.staticfiles",
    # ...
]

כמו כן, עליך לבטל את DEBUG על ידי הגדרתו ל-False:

# sitepoint_django/settings.py

DEBUG=False

עם צעדים אלו, אפשר לשרת באופן חלק קבצים הסטטיים שלך באמצעות החבילה WhiteNoise.

כדי לאמת ש-WhiteNoise משרת את הקבצים שלך למעשה, אפשר להסיר או להעיף תגיים על האפשרות django.contrib.staticfiles מרשימת ההגדרות INSTALLED_APPS. עם זאת, חשוב לציין שהסרת django.contrib.staticfiles תאפס כמה פקודות של ניהול קבצים סטטיים, כגון הפקודה collectstatic. פקודה זו היא חיונית לאספת ואיחוד קבצים סטטיים מהאפליקציות שלך לסרטן יחיד לשירות יעיל בסביבות ייצור.

אפשרויות הגדרת WhiteNoise מתקדמות

בעוד שהשלבים לעיל מספיקים עבור רוב המקרים, WhiteNoise מספק כמה אפשרויות נוספות להגדרה. לדוגמה, אפשר להוסיף דחיסה ותמיכה בקישוריות לפרויקט שלך. כדי לאפשר את זה, פתח את הקובץ sitepoint_django/settings.py והוסף את ההגדרות הבאות:

# sitepoint_django/settings.py

STORAGES = {
    # ...
    "staticfiles": {
        "BACKEND": "whitenoise.storage.CompressedManifestStaticFilesStorage",
    },
}

ההגדרה לעיל תבטיח שWhiteNoise ידחוס ויעביר את הקבצים הסטטיים לשמות ייחודיים, כך שיוכלו להתקלט בבטחה.

שימוש ב-WhiteNoise בסביבות מארח משותפות

מארח משותף הוא סוג של שירות מארח אינטרנט שבו מכלול רשתות מופעל על שרת פיזי אחד. בסיטואציה זו, משאבים כגון חלל דיסק, תוצאות חיבור, וכוח עיבוד משותפים בין משתמשים רבים, מה שהופך אותו לאופציה שיפורטית לאחסון אתרים קטנים עד בינוניים.

סביבות מארח משותפות בדרך כלל מנוהלות על ידי ספקי מארח, שמטפלים בתחזוקת השרת, אבטחה ותמיכה טכנית, מה שמאפשר לבעלי אתרים להתמקד בבניית וניהול האתרים שלהם מבלי להיות מוטרדים ממשימות ניהול שרת.

אתגרים בניהול קבצים סטטיים במארח משותף

בעוד שמארח משותף מציע פתרון אחסון זול ונוח עבור רבים מהאתרים, יש לו גם מגבלות בהשוואה לסוגים אחרים של אחסון, כגון שרתים פרטיים (VPS) או שרתים מיוחדים. המגבלות אלה כוללות את הדברים הבאים:

  • הגבלות על הגדרות ותצורות של שרתים, המגבילות את היכולת להתאים את תוכנת השרת או להתקין כלים נוספים.

  • מגבלות משאבים כגון מקום בזכרון משתתפות גם הן, שכן עשויות להיות הגבלות על כמות הבנד שניתן להשתמש בה לשירות הקבצים אלה ללקוחות.

  • ביצועים עשויים להיות אתגר נוסף באירוח משותף, משום ששיתוף משאבים עם משתמשים אחרים עשוי לגרום לזמני טעינה איטיים יותר לקבצים סטטיים, במיוחד בתקופות של תנופה גבוהה או שימוש במשאבים.

הגדרה לשימוש ב-WhiteNoise

WhiteNoise הוא חבילת Python המשלבת בצורה חלקה עם Django, מה שהופך אותו לבחירה אידאלית לשירות קבצים סטטיים בסביבות אירוח משותפות. בשונה מהתקנות תוכנה אחרות כגון Apache ו-Nginx, שאולי לא יהיו מותרים בסביבות אירוח מסוימות, WhiteNoise יכול להתקבל בקלות במקביל לחבילות הפרויקט האחרות שלך.

על ידי כונן Django להשתמש ב-WhiteNoise, אפשר לשרת קבצים סטטיים ביעילות ישירות מהיישומון של Django מבלי להזדקק לתוכנה של שרת נלווה. זה מפשט את תהליך ההתקנה ומבטיח תאימות עם קיוסר סוגי ספקי אחסון.

רוב ספקי האחסון המשותפים מספקים cPanel המאפשר לך לבצע התקנות שרת ועליות קבצים. אז ברגע שהעלית את הקבצים שלך, אפשר לבצע את השינויים הבאים לפרויקט settings.py קובץ:

# sitepoint_django/settings.py

STATIC_URL='static/'

# החלף את שם המשתמש בשם המשתמש שלך ב-cpanel
# השתמש ב-public_html אם אתה עובד על הדומיין הראשי שלך כמו https://example.com
STATIC_ROOT='/home/username/public_html/static'

# או 
# השתמש בשם התיקייה אם אתה עובד על תת-הדומיין כמו https://subdomain.example.com
STATIC_ROOT='/home/username/subdomain.mydomain.com/static'

עם ההגדרות האלה במקום, כל מה שאתה צריך לעשות הוא לרוץ את הפקודה collectstatic כך שהקבצים הסטטיים שלך יאוספו לאחת מהן STATIC_ROOT תיקיות לפי הדומיין.

שירות קבצים סטטיים מ-AWS S3

שירות האחסון הפשוט (S3) של אמזון הוא שירות אחסון אובייקטים מתקפל המוצע על ידי שירותי אמזון (AWS). זה מאפשר למשתמשים ליצור מרחבי אחסון הידועים כדליינים שבו אפשר לאחסן מסוגי הנתונים שלך כמו מסמכים, תמונות, וידאו ובפרט לטיוטא שלנו קבצים סטטיים.

AWS מציעה שיטת חינם עבור מספר שירותים שלה, כולל Amazon S3. השיטה החינמית מאפשרת למשתמשים להתחיל עם שירותי AWS בלי תשלום למשך תקופה מסוימת או עד לגבולות שימוש מסוימים. כדי להתחיל, אפשר להירשם לשיטה החינמית של S3. עם זאת, כדי להשלים את תהליך ההרשמה תצטרך לספק פרטי תשלום.

יצירת מפלס S3

כדי ליצור מפלס, עבור אל לוח הבקרה של S3 ולחץ על יצירת מפלס כפתור.

תן למפלס שם ייחודי התואם ל-DNS. אפשר גם לבחור אזור קרוב יותר לך או למשתמשים שלך.

הפעל ACL עבור המפלס.

הפעל גישה ציבורית למפלס, על ידי כיבוי חסימת גישה ציבורית מלאה.

לאחר יצירה מוצלחת, אפשר צריך לראות את המפלס שלך בדף הראשי של S3.

הפעלת גישה IAM

לאחר יצירת מפלס, אפשר להשתמש במפלס כמשתמש ראשי, אך AWS ממליץ ליצור קבוצת IAM (Identity Access Management) ולהקצות להם גישה רק למפלס מסוים.

יצירת קבוצת IAM

עבור אל דף IAM הראשי ובחר קבוצות משתמשים בסליל. לאחר מכן לחץ על יצירת קבוצה כפתור. קבע שם לקבוצה.

לאחר מכן תחת הקפדה על מדיניות הרשומות, חפש אחר S3 והקצה AmazonS3FullAccess ולאחר מכן לחץ על יצירת קבוצה כפתור.

יצירת משתמש IAM

בעודכם עדיין בדף IAM, בחרו ב-משתמשים בלוח בצד שמאל ולאחר מכן לחצו על הכפתור יצירת משתמש.

תן למשתמש של IAM שם ולחצו על הכפתור הבא.

תחת האפשרות קביעת הרשאות, השאר את הוספת משתמש לקבוצה כאפשרות נבחרת, לאחר מכן עברו ל-קבוצות משתמשים ובחרו בקבוצת המשתמשים שיצרתם למעלה ולאחר מכן לחצו על הכפתור הבא.

בדקו ולחצו על יצירת משתמש.

עכשיו לחצו על שם המשתמש כדי לצפות בפרטים של המשתמש. לחצו על הכרטיסייה רמזורים בטחוניים ולאחר מכן לחצו על יצירת מפתח גישה. בחרו ב-קוד מקומי ולחצו על הכפתור הבא.

לאחר מכן, לחצו על הכפתור יצירת מפתח גישה. אפשר להעתיק את המפתחות לקובץ .env שלכם אם יש לכם כזה, או להוריד את הקובץ CSV לשימוש מאוחר יותר.

הגדרת Django לשימוש ב-AWS S3 לקבצים סטטיים

לאחר יצירת באר ס3, אנו צריכים להגדיר את הפרויקט לשירות קבצים מס3. בקטע קודם, הגדרנו את WhiteNoise לשירות הנתונים הסטטיים שלנו. אנו צריכים לבטל את WhiteNoise כדי שנוכל לשדר את הנתונים מס3. כדי לעשות זאת, עברו לקובץ sitepoint_django/settings.py והפסיקו את השורות הרלוונטיות של הקוד:

# sitepoint_django/settings.py

INSTALLED_APPS = [
    # ...
    # "whitenoise.runserver_nostatic",
    # ...
]

MIDDLEWARE = [
    # ...
    # "whitenoise.middleware.WhiteNoiseMiddleware",
    # ...
]

# STORAGES = {
#     "staticfiles": {
#         "BACKEND": "whitenoise.storage.CompressedManifestStaticFilesStorage",
#     },
# }

הקוד לעיל מפריך את כל ההגדרות שקיימנו עבור WhiteNoise.

התקנת חבילות

כדי שהפרויקט יוכל לעבוד עם S3, אנו צריכים להתקין שתי חבילות: boto3 ו-django-storages. boto3 מספק את ה-API הנמוך הרמה ב-Python לאינטראקציה עם שירותי AWS, ו-django-storages מרחיב את יכולות אחסון הקבצים של Django כדי לשלבם עם ספקי אחסון ענן כמו Amazon S3, מה שמאפשר לך לנהל ולשרת באופן חלק קבצים סטטיים ומדיה ביישום Django שלך:

pip install boto3 django-storages

הגדרת הגדרות

כדי שהפרויקט שלנו יוכל לשרת קבצים מ-S3, אנו צריכים לבצע כמה שינויים בקובץ settings.py ולעדכן אותו עם הקוד הבא:

# sitepoint_django/settings.py
import os  # ראשית הוסיפו אימפורט למודול os

# הגדרות אחסון S3
STORAGES = {
    'staticfiles': {
        'BACKEND': 'storages.backends.s3boto3.S3Boto3Storage',
        'OPTIONS': {
            'bucket_name': os.getenv('AWS_STORAGE_BUCKET_NAME'),
            'location': 'static',
            'querystring_auth': False,
        },
    }
}

ההגדרות לעיל יוצרות מילון STORAGES המשמש כמכ容器 מרכזי להגדרת מאחסנים שונים המשמשים בתוך הפרויקט.

חשוב לציין שההגדרה הזו זמינה רק עבור גרסאות של Django מ -4.2 ומעלה. לגרסאות קודמות, עיין בתיעוד.

בקוד לעיל, יש לנו הגדרה עבור staticfiles המזהה את ההגדרה האחסונית לניהול קבצי סטטי.

לאחר ההגדרות של STORAGES אנו צריכים להוסיף כמה הגדרות ספציפיות של AWS בקובץ ההגדרות שלנו, אז גלול לחלק שבו תמצאו את ההגדרה STATIC_URL ובצע את השינויים הבאים: 

# sitepoint_django/settings.py

USE_S3 = os.getenv('USE_S3')

if USE_S3:
    AWS_ACCESS_KEY_ID = os.getenv('AWS_ACCESS_KEY_ID')
    AWS_SECRET_ACCESS_KEY = os.getenv('AWS_SECRET_ACCESS_KEY')
    AWS_S3_OBJECT_PARAMETERS = {
        "CacheControl": "max-age=2592000",
    }

else:
    STATIC_URL = 'static/'
    STATIC_ROOT = BASE_DIR / 'staticfiles'

העלאת קבצי סטטי ל-S3

ברגע שההגדרות מוכנות, המשימה הבאה היא להעלות את הקבצים הסטטיים שלכם לחריץ S3. אתם עושים זאת על ידי הריצה של collectstatic: 

python manage.py collectstatic  --no-input

זה יאסוף את כל הקבצים הסטטיים ביישומי הפרויקט שלנו, יעביר אותם לחריץ S3, וישאיר אותם בתיקיה static כפי שהוגדר במילון STORAGES. הדגל --no-input מורה לדאנגו לרוץ במצב לא אינטראקטיבי, ולהתעלם מכל הפקודות לקבלת קלט מהמשתמש.

כשמשתמשים ב-Django, הוא יבצע אוטומטית את תהליך איסוף הקבצים הסטטיים מבלי לדרוש כל עיסוק ידני מהמשתמש.

ריצה של הפרויקט

לאחר שכל ההגדרות מוכנות, תוכל להריץ את הפרויקט. בואו נריץ את הפרויקט בשלב הפיתוח ונשרוף את הקבצים ממבחן S3:

python manage.py runserver

כדי לוודא שאכן משרתים קבצים מ-S3, תוכל לבדוק את קוד המקור של הדף הבית:

<link rel="stylesheet" href="https://sitepoint-django-static.s3.amazonaws.com/static/static_demo/css/styles.css">

<img src="https://sitepoint-django-static.s3.amazonaws.com/static/static_demo/images/flowerImage.png" alt="Flower Image">

<script src="https://sitepoint-django-static.s3.amazonaws.com/static/static_demo/js/todays_date.js"></script>

התבוננות ביסודות ה-HTML מראה שאכן הכתובות האתריות מכוונות למבחן S3.

מסקנה

בסיכום, ניהול קבצים סטטיים ב-Django כרוך בהערכת דרישות הפרויקט, צרכי ההילוך והגבלות סביבת האחסון כדי לבחור את השיטה המתאימה ביותר.

לדוגמה, מידות WhiteNoise מספקת פתרון יעיל להגשת קבצים סטטיים בסביבות אחסון משותפות, שם מגבלות משאבים וגישה מוגבלת לשרת עשויות להיות מאתגרות.

על ידי כוונת הגדרות Django בהתאם והשימוש בכלים כמו WhiteNoise, מפתחים יכולים להבטיח שרת קבצים סטטיים נאמן ומותאם, ללא קשר לסביבת האחסון. כל שיטה מציעה יתרונות ושיקולים משלה, שדורש בחינה זהירה כדי לעמוד בצרכים הספציפיים של הפרויקט ולספק חוויה משתמשים חלקה.

כבר עסקנו במספר נקודות מרכזיות:

שיטות לניהול קבצים סטטיים. דיברנו על מספר גישות, כולל שירות קבצים סטטיים מקומית, שימוש בשרת הפיתוח המקומי של Django, שימוש בפתרונות אחסון שלישיים כמו Amazon S3, ושירות קבצים באמצעות חבילות כמו WhiteNoise. לכל שיטה יש יתרונות והגבלות משלה, תלויות בגורמים כמו קיבולת, ביצועים וקלות הפריסה.

הגדרות ופקודות נפוצות:

  • STATIC_ROOT: מציין את המדריך בו ייאספו הקבצים הסטטיים.
  • STATIC_URL: מגדיר את כתובת ה-URL הבסיסית לגישה לקבצים הסטטיים דרך שרת האינטרנט.
  • STATICFILES_DIRS: מציין מדריכים נוספים המכילים נכסים סטטיים.
  • STATICFILES_STORAGE: מכוון את מאחז האחסון לטפל בקבצים סטטיים.
  • collectstatic: אוסף את כל הנכסים הסטטיים מכל מדריכי האפליקציות ל-STATIC_ROOT.

קרא עוד:

Source:
https://www.sitepoint.com/managing-static-files-in-django-a-comprehensive-guide/