Как создать сайт или приложение на Django Python с нуля

Для создания веб-приложений без глобальных затрат многие разработчики выбирают фреймворк Django. Он предоставляет все основные компоненты для создания веб-приложений: ORM, маршрутизацию, шаблонизатор, админ-панель, аутентификацию. Однако для продакшен-среды требуются дополнительные инструменты — веб-сервер (Nginx/Apache), WSGI-сервер (Gunicorn/uWSGI), а для асинхронных задач — Celery и брокер сообщений (Redis/RabbitMQ).

Эта статья — гайд по подготовке к разработке и созданию приложения.

Инструкции

Иллюстрация для статьи на тему «Как создать сайт или приложение на Django Python с нуля»

20 апреля 2026 19 минут

Александра ГонтареваРедактор блога

Время чтения19 минут

Дата публикации20 апреля 2026

Продукты из этой статьи:

Evolution Managed PostgreSQL®

Содержание

Подготовка к разработке
Создание и запуск нового проекта Django
Создание и настройка приложения в Django
Разработка моделей и миграции
Создание представлений и маршрутизация
Работа с шаблонами
Статические файлы и медиа
Деплой Django-приложения

Подготовка к разработке

Подготовка заключается в установке Python и самого фреймворка, создании виртуального окружения.

Установка Python и создание виртуального окружения

Убедитесь, что у вас установлен Python 3.10 или выше (рекомендуется Python 3.12), так как Django 5.0+ требует Python 3.10+. Если вы используете Django 4.2 LTS, подойдут версии Python 3.8 – 3.12. Для новых проектов рекомендуется Python 3.12 и Django 5.1. Если его еще нет, действуйте так:

На официальном сайте python.org в разделе загрузок выберите нужную версию для вашей операционной системы. Скачайте и запустите установочный файл. Проверьте, что установка включает менеджер пакетов pip.
Через терминал или командную строку проверьте, установился ли Python. Это делается с помощью команды python --version. Она выведет версию Python. Есть аналогичная команда и для проверки версии pip — python -m pip --version.
Создайте виртуальное окружение, которое позволит отдельно от глобальной системы хранить зависимости проекта и предотвращать конфликты между разными проектами. Это можно сделать с помощью инструмента venv. В папке вашего проекта выполните команду python -m venv venv. Укажите имя директории, где будут храниться файлы виртуального окружения.
Активируйте виртуальное окружение. На Windows — venv\Scripts\activate, на Linux/macOS — source venv/bin/activate. Если имя окружения появилось в командной строке, значит, pip install будет работать в изолированном пространстве.

Следите за обновлениями pip,чтобы избежать сбоев в работе и повысить уровень безопасности. Для обновления используйте команду python -m pip install --upgrade pip.

Дарим до 20 000 бонусов

4 000 бонусов — физическим лицам, 20 000 бонусов — юридическим

Установка Django

Можно установить Django через pip. В виртуальном окружении выполните:

pip install django

Можно добавить явную версию фреймворка. После выполнения команды Django будет установлен в изолированную среду разработки. Чтобы в этом убедиться, примените:

python -m django --version

Если отображается установленная версия Django, можно переходить к созданию первого проекта.

Создание и запуск нового проекта Django

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

Создание проекта Django

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

cd путь_к_папке_с_проектами

С помощью утилиты django-admin создайте новый проект командой:

django-admin startproject mysite

Имя проекта — mysite. Можете указать любое название, которое будет отображать суть вашего проекта. После выполнения команды в папке появится директория с этим именем. Перейдите туда и проверьте структуру. Она будет примерно такой:

manage.py — главный ключевой файл проекта, через который будут выполняться команды.
mysite/ — основной пакет проекта.

Пакет mysite/ содержит __init__.py, файл настроек settings.py, файл URL-маршрутов проекта urls.py и точки входа для серверов — asgi.py и wsgi.py. Такая структура создается автоматически.

После проверки структуры зайдите внутрь директории и выполните:

cd mysite

Примерно так выглядит проект на Django Python

Тестовый запуск сервера

После создания проекта в целях проверки нужно запустить сервер разработки. В папке проекта выполните команду:

python manage.py runserver

Если сервер успешно запустится, вы увидите в терминале сообщение об этом и адрес, по которому он доступен. Например:

http://127.0.0.1:8000/

В браузере перейдите по указанному адресу. Если проект установлен, появится стандартная приветственная страница Django и сообщение о том, что сервер запущен, настройки выполнены верно и все готово к дальнейшей разработке. Затем можно остановить сервер разработки, вернувшись в терминал и нажав Ctrl+C.

Встроенный сервер runserver используется ТОЛЬКО для разработки и тестирования. Категорически запрещено использовать его в продакшн-среде, так как он:

однопоточный (не обрабатывает параллельные запросы);
не имеет защиты от медленных атак;
некорректно обрабатывает статические файлы;
не поддерживает HTTPS в продакшен-конфигурации.

Для продакшена используйте связку Gunicorn (WSGI-сервер) + Nginx (веб-сервер).

Создание и настройка приложения в Django

Приложение в Django — модуль с определенной структурой файлов. Он содержит модели представления, маршруты, данные и другие компоненты.

Создание приложения

Для создания нового приложения в вашем проекте перейдите в корневую директорию, где хранится файл manage.py. Выполните команду, подставив свое название:

python manage.py startapp имя_приложения

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

__init__.py — представляет папку с кодом в виде пакета Python.
admin.py — позволяет регистрировать модели базы данных в административной панели.
apps.py — файл конфигурации приложения.
models.py — описание моделей данных.
tests.py — модуль для написания автоматизированных тестов.
views.py — файл, содержащий логику обработки запросов.
migrations/ — каталог для файлов миграций.

Чтобы Django «увидел» приложение, зарегистрируйте его, добавив в конфигурацию проекта. В файле settings.py найдите INSTALLED_APPS и внесите строку с названием приложения. Схематично это выглядит так:

INSTALLED_APPS = [
    # другие приложения
    "имя_приложения",
]

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

Настройка базы данных

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

PostgreSQL — надежная масштабируемая СУБД с поддержкой сложных запросов, транзакций, JSON-полей и других продвинутых функций. Оптимальна для большинства проектов. Если нужно облачное решение, подойдут управляемые сервисы, например, Evolution Managed PostgreSQL от Cloud.ru, Amazon RDS для PostgreSQL или Google Cloud SQL.
SQLite — СУБД, которая используется в Django по умолчанию. Не требует отдельного сервера и тонких настроек, подходит для небольших проектов.
MySQL или ее форк MariaDB — популярные и достаточно простые решения, которые подойдут для не слишком масштабных веб-проектов.
Oracle — коммерческая корпоративная СУБД, широко распространенная в крупных enterprise-проектах (финансы, госсектор). В экосистеме Django используется редко из-за высокой стоимости лицензирования и сложности настройки, но в Java/.NET-среде является стандартом де-факто для высоконагруженных систем.

Краткая сравнительная характеристика этих СУБД:

СУБД	Тип	Применимость	Преимущества	Недостатки
SQLite	Реляционная	Локальная разработка, тестирование, небольшие проекты	Простота настройки, отсутствие сервера	НЕ рекомендуется для продакшена при интенсивной записи (блокировки на уровне БД), нет поддержки параллельной записи
PostgreSQL	Реляционная	Масштабируемые и сложные проекты, поддержка транзакций	Высокая производительность, поддержка сложных запросов, JSONB (индексируемый JSON), полнотекстовый поиск, транзакции ACID	Потребность в отдельном сервере, сложная настройка для новичков
MySQL/MariaDB	Реляционная	Средние и большие веб-приложения, поддержка репликации	Простота использования, популярность среди веб-серверов	Меньше функционала по сравнению с PostgreSQL, проблемы с транзакциями для движка MyISAM
Oracle	Реляционная	Корпоративные проекты, которые в перспективе требуют масштабирования	Высокая производительность при больших объемах данных	Сложная настройка, высокая стоимость, сложность администрирования

Для локальной разработки и быстрого старта подойдет SQLite. Для продакшен-среды выбирайте PostgreSQL.

Откройте файл settings.py и выберите раздел DATABASES. Там имеется конфигурация для SQLite. Примерно такая:

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.sqlite3",
        "NAME": BASE_DIR / "db.sqlite3",
    }
}

Если выбрали PostgreSQL, загрузите пакет psycopg2 или psycopg2-binary.

для разработки подойдет psycopg2-binary (установка: pip install psycopg2-binary);
для продакшен рекомендуется устанавливать psycopg2 (требует компиляторов и библиотеки libpq-dev), так как binary-версия может быть несовместима с обновлениями системных библиотек.

Конфигурация следующая:

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": "название_базы_данных",
        "USER": "имя_пользователя",
        "PASSWORD": "пароль",
        "HOST": "адрес_сервера",  # локально: "localhost" или IP
        "PORT": "5432",          # стандартный порт PostgreSQL
    }
}

Для MySQL/MariaDB установите драйвер pip install mysqlclient. Конфигурация будет такой:

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.mysql",
        "NAME": "название_базы",
        "USER": "имя_пользователя",
        "PASSWORD": "пароль",
        "HOST": "localhost",
        "PORT": "3306",
    }
}

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

python manage.py migrate

Разработка моделей и миграции

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

Управляемый PostgreSQL

Масштабируйте БД в 2 клика с SLA 99,7%

Подробнее

Создание моделей

Модель — Python-класс, наследуемый от django.db.models.Model. Каждая неабстрактная модель соответствует отдельной таблице в базе данных. При использовании абстрактных моделей (abstract = True) или proxy-моделей таблица не создается или переиспользуется.

Модель нужно создавать в файле models.py. Она будет выглядеть примерно так:

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

В примере указано строковое поле ограниченной длины — CharField, поле для объемного текста — TextField, поле даты и времени — DateTimeField. Особенности отображения в административной панели определяет параметр __str__.

В модели Django можно задать разные типы полей, такие, как строки, числа, даты, булевы значения, файлы, изображения, JSON. Выбирайте те, что будут соответствовать типам данных в СУБД.

Для управления данными через административную панель Django зарегистрируйте модель в admin.py. Как это выглядит:

from django.contrib import admin
from .models import Article

admin.site.register(Article)

После регистрации модель будет отображаться в админ-интерфейсе /admin/. Для ее просмотра или редактирования нужны права суперпользователя в системе.

Проведение миграций

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

Для создания миграций после запуска новой модели или изменения существующей выполните команду:

python manage.py makemigrations

Django проанализирует изменения в models.py и в папке migrations/ создаст файл миграции. Он будет содержать инструкции, которые описывают, какие таблицы добавить, удалить или редактировать. Чтобы применить изменения к базе данных, выполните:

python manage.py migrate

Информация о примененных миграциях хранится в специальной таблице БД. С ее помощью можно последовательно выполнять изменения, «откатываться» назад и синхронизировать структуру базы данных между разными средами разработки.

Если хотите изменить существующую модель и применить миграцию, выполните сначала makemigrations, затем migrate.

Создание представлений и маршрутизация

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

Создание представлений

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

Есть два типа представлений. Первый — функциональные. Это Python-функции, которые подходят для небольших задач. Пример:

from django.shortcuts import render
from .models import Article

def article_list(request):
    articles = Article.objects.all()
    return render(request, "blog/article_list.html", {"articles": articles})

Классовые представления позволяют применять объектно-ориентированный подход. Вместо одной функции пишется класс, который может наследовать методы от встроенных универсальных представлений. Пример:

from django.views.generic import ListView
from .models import Article

class ArticleListView(ListView):
    model = Article
    template_name = "blog/article_list.html"
    context_object_name = "articles”

ListView автоматически получает все объекты модели через Model.objects.all(). Для больших наборов данных ОБЯЗАТЕЛЬНО используйте пагинацию:

class ArticleListView(ListView):
    model = Article
    template_name = "blog/article_list.html"
    context_object_name = "articles"
    paginate_by = 10  # Количество объектов на страницу

Без пагинации ListView загрузит ВСЕ записи из БД, что может вызвать проблемы с производительностью.

Настройка маршрутов (URLs)

Маршрутизация в Django настраивается через файлы urls.py. В корневом urls.py проекта нужно подключить маршруты приложений, например:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path("admin/", admin.site.urls),
    path("blog/", include("blog.urls")),
]

admin/ — административная панель, blog/ — префикс для маршрутов приложения. За подключение файла urls.py внутри приложения отвечает include().

В приложении нужно создать собственный файл urls.py:

from django.urls import path
from .views import article_list, ArticleListView

urlpatterns = [
    path("", article_list, name="article_list"),
]

Django поддерживает динамические параметры в URL. Например:

path("article/<int:pk>/", ArticleDetailView.as_view(), name="article_detail"),

<int:pk> — параметр, передаваемый в представление. Django автоматически преобразует его к нужному типу.

Для генерации ссылок в шаблонах используется параметр name:

<a href="{% url 'article_detail' pk=article.pk %}">Подробнее</a>

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

Работа с шаблонами

Система шаблонов отвечает за формирование HTML-страниц. Она позволяет корректно выводить данные в браузере и отделять логику приложения от интерфейса. По умолчанию Django использует встроенный шаблонизатор Django Template Language (DTL). Однако Django также поддерживает альтернативные шаблонизаторы, такие как Jinja2 (более быстрый и гибкий), которые можно подключить через настройку TEMPLATES в settings.py.

Шаблоны представляют собой HTML-файлы с инструкциями для вывода данных. Они хранятся в папке templates. Структура выглядит так:

имя_приложения/
    templates/
        имя_приложения/
            template.html

Чтобы Django находил шаблоны, проверьте, что в settings.py настроен параметр TEMPLATES. В новых версиях фреймворка конфигурация задается автоматически. Вам останется только убедиться, что она верная.

Передача данных в шаблон из представления

Шаблон через контекст получает данные из представления, которое выглядит подобным образом:

from django.shortcuts import render
from .models import Article

def article_list(request):
    articles = Article.objects.all()
    return render(request, "blog/article_list.html", {"articles": articles})

Здесь указан путь к шаблону — blog/article_list.html. Контекстом выступает словарь {"articles": articles}.

Вывод переменных и управляющие конструкции

Данные выводятся с использованием двойных фигурных скобок. Пример:

<h1>Список статей</h1>

{% for article in articles %}
    <h2>{{ article.title }}</h2>
    <p>{{ article.content }}</p>
{% endfor %}

Закрывающий тег {% endfor %} обязателен. {{ }} применяется для вывода переменных, {% %} — для управляющих конструкций.

В Django Template Language несколько вариантов управляющих конструкций, например, условие, цикл и фильтры. Пример условия:

{% if articles %}
    <p>Найдено статей: {{ articles|length }}</p>
{% else %}
    <p>Статей пока нет.</p>
{% endif %}

Пример цикла:

{% for article in articles %}
    {{ article.title }}
{% endfor %}

Пример фильтров, позволяющих форматировать данные:

{{ article.created_at|date:"d.m.Y" }}

Наследование шаблонов

Наследование шаблонов — технология, которая позволяет использовать базовый файл (base.html) с общими элементами в других шаблонах. Пример base.html:

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}Мой сайт{% endblock %}</title>
</head>
<body>
    {% block content %}{% endblock %}
</body>
</html>

Как выглядит наследование в других шаблонах:

{% extends "base.html" %}

{% block title %}Главная{% endblock %}

{% block content %}
    <h1>Добро пожаловать</h1>
{% endblock %}

Наследование помогает экономить время и избегать ошибок при подготовке новых шаблонов.

Статические файлы и медиа

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

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

Статические файлы — это ресурсы, которые в процессе работы приложения остаются неизменными. Например, это шрифты, иконки, JavaScript и CSS.

Для работы со статическими файлами в settings.py нужно указать параметры:

STATIC_URL = "static/”

В продакшен-среде нужно задать директорию для статических файлов:

STATIC_ROOT = BASE_DIR / "staticfiles”

Если есть отдельная папка для статических файлов, можно добавить следующее:

STATICFILES_DIRS = [
    BASE_DIR / "static",
]

Перейдем к размещению статических файлов в приложении. Обычно схема выглядит так:

имя_приложения/
    static/
        имя_приложения/
            css/
            js/
            images/

После определения схемы в шаблоне нужно подключить тег static:

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

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

python manage.py collectstatic

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

Обработка медиаконтента

Медиафайлы — пользовательский контент, например, фотографии, документы, картинки в профиле. В одной папке со статическими файлами их хранить нельзя, поскольку они могут меняться. Для них предусмотрена отдельная настройка в settings.py:

MEDIA_URL = "media/"
MEDIA_ROOT = BASE_DIR / "media”

MEDIA_ROOT — папка на сервере, куда будут сохраняться медиафайлы. MEDIA_URL — URL-префикс для доступа к ним.

В моделях для загрузки таких файлов нужны специальные поля подобного типа:

from django.db import models

class Profile(models.Model):
    avatar = models.ImageField(upload_to="avatars/")

Для работы с изображениями нужно дополнительно установить библиотеку Pillow. Это делается с помощью команды pip install Pillow.

Если хотите, чтобы в режиме разработки Django самостоятельно обслуживал медиафайлы, в urls.py проекта нужно добавить следующее:

from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    # маршруты приложения
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

В продакшен-среде медиаконтент обслуживается веб-сервером (Nginx/Apache), CDN (Content Delivery Network, например, CloudFront, Cloudflare) или облачным хранилищем (Amazon S3, Google Cloud Storage, Yandex Object Storage). Использование CDN ускоряет загрузку контента для пользователей по всему миру.

Деплой Django-приложения

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

Подготовка к деплою

Первым делом отключите режим разработки, добавив в файл settings.py параметр:

DEBUG = False

Настройте список разрешенных хостов, чтобы Django принимал запросы от указанных доменов:

ALLOWED_HOSTS = ["example.com", "www.example.com"]

Уберите из кода SECRET_KEY, API-ключи, пароли от баз данных и другие конфиденциальные сведения. Используйте современные подходы:

для разработки: переменные окружения и библиотека python-dotenv;
для продакшен: менеджеры секретов (HashiCorp Vault, AWS Secrets Manager, Google Cloud Secret Manager).

Пример с python-dotenv:

# .env файл (не добавлять в Git!)
SECRET_KEY=ваш_секретный_ключ
DB_PASSWORD=пароль

# settings.py
from dotenv import load_dotenv
load_dotenv()
SECRET_KEY = os.getenv('SECRET_KEY')

Что еще рекомендуем сделать перед деплоем:

проверить настройки базы данных;
настроить обработку статических файлов;
убедиться, что используется HTTPS;
включить такие параметры, как CSRF_COOKIE_SECURE, SESSION_COOKIE_SECURE, SECURE_BROWSER_XSS_FILTER;
настроить логирование для отслеживания ошибок и сбоев.

Финально протестируйте настройки:

python manage.py check --deploy

Эта команда проверяет только настройки Django (DEBUG, ALLOWED_HOSTS, SECURE_* и т.д.). Она не проверяет конфигурацию веб-сервера (Nginx/Apache), SSL-сертификаты или работу базы данных в продакшен-режиме.

Архитектура приложения

Размещение на сервере

Есть несколько вариантов развертывания проекта на выбранном хостинге. Первый — виртуальный сервер. Схема размещения выглядит так:

Установка Python и создание виртуального окружения.
Установка зависимостей из requirements.txt.
Выполнение миграций.
Сбор статических файлов.
Настройка сервера приложения.
Настройка веб-сервера.

В продакшене Django обычно используется связка WSGI-сервера (например, Gunicorn или uWSGI) и веб-сервера (Nginx или Apache). WSGI-сервер запускает Python-код Django, а веб-сервер принимает HTTP-запросы, раздает статические файлы и проксирует динамические запросы к WSGI-серверу.

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

Третий вариант — контейнеризация через Docker. Проект упаковывается в контейнер с помощью Dockerfile, что обеспечивает воспроизводимость окружения.

Для локальной разработки и простых проектов: используйте Docker Compose (достаточно одного файла docker-compose.yml).
Для масштабируемых систем на множестве серверов: используйте оркестраторы (Kubernetes, Docker Swarm). Kubernetes требуется, когда у вас несколько реплик приложения, автоматическое масштабирование и балансировка нагрузки.

Независимо от выбранного способа развертывания не забудьте настроить резервное копирование базы данных и мониторинг состояния сервера.

Заключение

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