Управление статическими файлами в Django: Полное руководство

В этом уроке мы рассмотрим, что такое статические файлы в Django, преимущества эффективного управления ими, их назначение в веб-приложениях, и мы создадим демонстрационный проект, чтобы показать, как управлять и обслуживать статические файлы с использованием различных методов и инструментов.

Django — это высокоуровневая Python-платформа для веб-разработки, которая предоставляет веб-разработчикам мощный набор инструментов для создания веб-приложений быстро и эффективно.

В то время как Django отлично подходит для создания веб-приложений быстро и эффективно, также важно заботиться о внешнем виде и ощущениях от веб-приложений, которые вы разрабатываете. Для этого необходимо научиться управлять ресурсами, которые поддерживают и обеспечивают внешний вид ваших приложений.

Статические файлы в Django

В Django статические файлы — это файлы, которые предоставляются клиенту напрямую без какой-либо обработки сервером.

К ним обычно относятся CSS, JavaScript файлы, изображения, иконки, шрифты и другие ресурсы, необходимые для внешнего вида и ощущений вашего веб-приложения.

Django предоставляет механизмы для эффективного управления и предоставления этих статических файлов, обеспечивая плавный пользовательский опыт.

Эффективное управление статическими файлами

Чтобы обеспечить хороший пользовательский опыт для пользователей вашего веб-приложения и чтобы приложение работало как ожидается, необходимо эффективно управлять статическими файлами.

Правильная организация и кеширование статических файлов обеспечат быстрое время загрузки страниц и улучшат отзывчивость, повышая общую удовлетворенность пользователей.

Django предлагает различные инструменты и конвенции для помощи в управлении статическими файлами.

Цель статических файлов в веб-приложениях

Статические файлы очень важны, так как они определяют, как выглядит и ощущается веб-приложение. Они определяют, как стилизованы компоненты в приложении, как они реагируют на взаимодействия пользователя, и в конечном итоге, что пользователь видит, когда он посещает определенное веб-приложение.

Когда вы эффективно обслуживаете статические файлы, вы сможете создать привлекательный и отзывчивый пользовательский интерфейс, что сделает приложение более привлекательным и удобным для пользователей.

Настройка демонстрационного проекта

Чтобы проиллюстрировать концепции управления статическими файлами в Django, мы создадим демонстрационный проект с нуля.

В этом проекте будет включено создание проекта Django, настройка настроек статических файлов и интеграция статических файлов в простую веб-приложение.

Следуя демонстрационному проекту, вы получите практический опыт управления статическими файлами в Django и поймете их значимость в веб-разработке.

Для целей этого учебника мы создадим стартовую страницу таким образом, чтобы когда пользователи посещают домашнюю страницу нашего проекта, они увидят стильное приветствие заголовок на сайте. Он также отобразит текущую дату с помощью JavaScript, и мы также предоставим изображение для завершения страницы.

Создание каталога для размещения проекта

Начнем с создания каталога, который будет содержать демонстрационный проект с помощью следующей команды:

mkdir sitepoint_django_static_tut

Создание виртуальной среды

Рекомендуется создать и изолировать новые проекты в виртуальных средах. Это означает, что каждый проект будет иметь свои собственные зависимости, не затрагивая глобальное установление Python.

Мы будем использовать пакет virtualenv для его создания. Если он не установлен в вашей среде разработки, установите его с помощью команды pip install virtualenv, и создайте виртуальную среду, используя следующую команду:

virtualenv myenv

Вышеуказанная команда создает виртуальную среду с именем myenv. Чтобы использовать виртуальную среду, ее необходимо активировать:

Linux/macOS:

. myenv/bin/activate

Windows:

. 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, который говорит Django, что мы включаем 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, форматирует её в строку и отображает в div с идентификатором 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 и запомните его имя.

Настройка настроек статических файлов

Чтобы обслуживать статические файлы в режиме разработки, необходимо установить несколько параметров в файле Django settings.py. Откройте файл sitepoint_django/settings.py и проверьте, есть ли у вас следующие настройки:

# sitepoint_django/settings.py

DEBUG=True

При разработке рекомендуется установить DEBUG в значение True в настройках вашего проекта Django. Это настройка включает различные функции отладки, включая подробные сообщения об ошибках и трассировки стека, которые бесценны для диагностики и устранения проблем во время разработки.

Кроме того, когда DEBUG установлен в True, приложение django.contrib.staticfiles автоматически обслуживает статические файлы из директории static каждого приложения. Это поведение упрощает процесс разработки, устраняя необходимость в ручной настройке для обслуживания статических файлов.

В настройке INSTALLED_APPS проверьте, добавлено ли django.contrib.staticfiles. Если нет, добавьте его над приложениями, которые у вас есть в проекте. Например, в этом проекте добавьте его над строкой приложения static_demo, как показано ниже:

# sitepoint_django/settings.py`

INSTALLED_APPS = [

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

Приложение django.contrib.staticfiles, предоставляемое Django, является важным для обслуживания статических файлов во время разработки. По умолчанию оно обходит приложения вашего проекта для поиска директорий со статическими файлами в каждом приложении. Однако, если у вас есть дополнительные статические ресурсы, которые не связаны с каким-либо конкретным приложением, вы все равно можете сделать их доступными для 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 обслуживать статические ресурсы из URL-пути /static/. Это означает, что, например, файл стилей, расположенный в приложении static_demo, будет доступен по URL, подобному http://127.0.0.1:8000/static/static_demo/css/styles.css.

Обновление шаблона

Чтобы использовать статические файлы в шаблоне, нам нужно обновить его следующим HTML:

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

<!-- добавить функциональность обработки статических файлов -->
{% 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>

    <!-- ссылка на css ниже -->
    <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>
    <!-- ссылка на изображение ниже -->
    <img src="{% static 'static_demo/images/flowerImage.png' %}" alt="Flower Image"> 

    <!-- ссылка на js ниже -->
    <script src="{% static 'static_demo/js/todays_date.js' %}"></script>
</body>
</html>

Это обновление шаблона знакомит нас с новым тегом: {% load static %}. Этот тег загружает функциональность обработки статических файлов, предоставляемую движком шаблонов Django. Включение этого тега в файл шаблона Django позволяет нам использовать шаблонные теги и фильтры, связанные со статическими файлами.

Например, использование этого механизма в нашем шаблоне позволяет нам ссылаться на статические файлы, такие как изображения, CSS и JS, в HTML-элементах. Также это позволяет Django генерировать 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. Если мы посетим эту ссылку, то увидим страницу, похожую на представленную ниже.

Наличие подобной картинки показывает, что статические файлы были применены корректно.

Следует отметить, что в процессе разработки Django, когда DEBUG=True в настройках вашего проекта, и включена django.contrib.staticfiles, это позволяет серверу разработки Django (runserver) обслуживать статические файлы. В этом случае любые изменения в статических файлах, таких как CSS, JavaScript или изображения, автоматически обнаруживаются и применяются Django. Этот бесшовный процесс значительно упрощает разработку, так как вы сразу увидите результаты своих изменений, не нуждаясь в ручном обновлении или перезапуске сервера.

Однако в производственных средах для обслуживания статических файлов обычно используется отдельный веб-сервер или 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"

Вышеуказанная настройка сообщает Django, что при выполнении collectstatic все статические ресурсы во всех приложениях вашего проекта будут собраны и сохранены в этом каталоге с именем staticfiles.

Следующее, что нужно сделать, это запустить управляющую команду collectstatic:

python manage.py collectstatic

Чтобы включить WhiteNoise, его нужно добавить в список настроек MIDDLEWARE, отредактировать файл settings.py и добавить middleware WhiteNoise после Django SecurityMiddleware и перед всеми другими middleware:

# sitepoint_django/settings.py

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

Использование WhiteNoise в разработке

Только с вышеуказанными шагами WhiteNoise может обслуживать ваши статические файлы в производстве. Но если в этот момент запустить проект, сервер разработки Django автоматически возьмет на себя обработку статических файлов. Но чтобы извлечь выгоду из похожего поведения в разработке и в производстве, хорошей идеей будет использовать его для обслуживания файлов в разработке также.

Для этого мы отключим обработку статических файлов 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 в средах с совместным хостингом

Совместный хостинг — это тип веб-хостинга, при котором несколько веб-сайтов размещаются на одном физическом сервере. В этом случае ресурсы, такие как дисковое пространство, пропускная способность и вычислительная мощность, делятся между несколькими пользователями, что делает его экономичным вариантом для хостинга небольших и средних веб-сайтов.

Среды с совместным хостингом обычно управляются провайдерами хостинга, которые занимаются обслуживанием сервера, безопасностью и технической поддержкой, что позволяет владельцам веб-сайтов сосредоточиться на создании и управлении своими сайтами, не беспокоясь о задачах администрирования сервера.

Проблемы управления статическими файлами в совместном хостинге

Хотя совместный хостинг предлагает доступное и удобное решение для многих веб-сайтов, он имеет ограничения по сравнению с другими типами хостинга, такими как виртуальные частные серверы (VPS) или dedicated серверы. К таким ограничениям относятся следующие:

Ограничения на конфигурацию и настройки сервера, ограничивающие возможности настройки программного обеспечения сервера или установки дополнительных инструментов.
Ресурсные ограничения, такие как место на диске, также играют роль, поскольку могут быть ограничения на объем пропускной способности, который можно использовать для предоставления этих файлов посетителям.
Производительность может быть еще одной проблемой в хостинге на совместной основе, поскольку совместное использование ресурсов с другими пользователями может привести к более медленным временам загрузки статических файлов, особенно во время периодов высокой нагрузки или использования ресурсов.

Настройка для использования WhiteNoise

WhiteNoise — это пакет Python, который плавно интегрируется с Django, что делает его идеальным выбором для обслуживания статических файлов в средах совместного хостинга. В отличие от других программных установок, таких как Apache и Nginx, которые могут быть недопустимыми в определенных хостинг-средах, WhiteNoise можно легко установить вместе с другими пакетами вашего проекта.

Настроив Django для использования WhiteNoise, вы можете эффективно обслуживать статические файлы непосредственно из вашего приложения Django, не требуя дополнительного серверного программного обеспечения. Это упрощает процесс настройки и обеспечивает совместимость с широким спектром хостинг-провайдеров.

Большинство провайдеров совместного хостинга предоставляют cPanel, который позволяет выполнять конфигурации сервера и загружать файлы. После загрузки файлов вам нужно внести следующие изменения в файл settings.py проекта:

# sitepoint_django/settings.py

STATIC_URL='static/'

# замените username на ваше имя пользователя 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

Amazon Simple Storage Service (S3) — это масштабируемая служба объектного хранилища, предлагаемая Amazon Web Services (AWS). Она позволяет пользователям создавать хранилища, известные как бакеты, где можно хранить различные типы данных, такие как документы, изображения, видео, и, что важно для нашего урока, статические файлы.

AWS предлагает бесплатный тариф для некоторых своих услуг, включая Amazon S3. Бесплатный тариф позволяет пользователям начать использовать услуги AWS бесплатно в течение определенного периода или до достижения конкретных лимитов использования. Чтобы начать, вы можете зарегистрироваться на бесплатный тариф S3. Однако для завершения процесса регистрации вам потребуется предоставить информацию о способе оплаты.

Создание бакета S3

Чтобы создать бакет, перейдите на панель управления S3 и нажмите на кнопку Создать бакет.

Дайте бакету уникальное имя, совместимое с DNS. Вы можете выбрать регион, который ближе к вам или вашим пользователям.

Включите ACL для бакета.

Включите публичный доступ к бакету, отключив Блокировать все публичные доступы.

После успешной создачи, вы должны увидеть свой бакет на главной странице S3.

Включение доступа IAM

После создания бакета, вы можете использовать его как корневой пользователь, но AWS рекомендует создать группу пользователей IAM и назначить им доступ только к определенному бакету.

Создание группы IAM

Перейдите на главную страницу IAM и выберите Группы пользователей в боковой панели. Затем нажмите кнопку Создать группу. Назначьте группе имя.

Затем под Прикрепить политики разрешений, найдите S3 и назначьте AmazonS3FullAccess, затем нажмите кнопку Создать группу.

Создание пользователя IAM

Пока еще на странице IAM, выберите Пользователи в панели слева и нажмите кнопку Создать пользователя.

Дайте пользователю IAM имя и нажмите кнопку Далее.

Под опцией Установить разрешения, оставьте Добавить пользователя в группу выбранным, затем перейдите в Группы пользователей и выберите группу пользователей, которую вы создали ранее, затем нажмите кнопку Далее.

Просмотрите и нажмите Создать пользователя.

Теперь нажмите на имя пользователя, чтобы просмотреть детали пользователя. Нажмите на вкладку Безопасные учетные данные и затем нажмите Создать ключ доступа. Выберите Местный код и нажмите кнопку Далее.

После этого, нажмите кнопку Создать ключ доступа. Вы можете скопировать ключи в свой файл .env, если у вас есть, или скачать CSV файл для последующего использования.

Настройка Django для использования AWS S3 для статических файлов

После создания бакета S3, нам нужно настроить проект для обслуживания файлов из S3. В предыдущем разделе мы настроили WhiteNoise для обслуживания наших статических ресурсов. Нам нужно отключить WhiteNoise, чтобы мы могли обслуживать ресурсы из S3. Для этого перейдите в файл 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 предоставляет низкоуровневый Python API для взаимодействия с 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 работать в неинтерактивном режиме, пропуская любые запросы на ввод данных пользователем.

При использовании 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-элементов показывает, что URL-адреса действительно указывают на бакет S3.

Заключение

В заключение, управление статическими файлами в Django включает оценку требований проекта, потребностей в масштабировании и ограничений окружения размещения для выбора наиболее подходящего метода.

Например, Middleware WhiteNoise предлагает эффективное решение для обслуживания статических файлов в средах с общим хостингом, где ограниченные ресурсы и ограниченный доступ к серверу могут представлять проблемы.

Правильной настройкой настроек Django и использованием инструментов, таких как WhiteNoise, разработчики могут обеспечить надежное и оптимизированное обслуживание статических файлов, независимо от окружения размещения. Каждый метод предлагает свои преимущества и соображения, требующие тщательной оценки для удовлетворения конкретных потребностей проекта и обеспечения безупречного пользовательского опыта.

Мы рассмотрели несколько ключевых моментов:

Методы управления статическими файлами. Мы обсудили различные подходы, включая обслуживание статических файлов локально, использование встроенного сервера разработки Django, использование сторонних решений для хранения, таких как Amazon S3, и обслуживание файлов с помощью пакетов, таких как WhiteNoise. Каждый метод имеет свои преимущества и соображения, зависящие от таких факторов, как масштабируемость, производительность и простота развертывания.

Общие настройки и команды:

STATIC_ROOT: указывает директорию, где будут храниться собранные статические файлы.
STATIC_URL: определяет базовый URL для доступа к статическим файлам через веб-сервер.
STATICFILES_DIRS: указывает дополнительные директории, содержащие статические ресурсы.
STATICFILES_STORAGE: настраивает хранилище для обработки статических файлов.
collectstatic: собирает все статические ресурсы из всех директорий приложений в STATIC_ROOT.

Дальнейшее чтение: