Как сделать api для сайта django

Пишем приложение с бэкендом на Django и фронтендом на React

Создаём проект Django в виртуальном окружении Python

Создайте новую папку и перейдите в неё:

mkdir django-react cd $_

Потом активируйте виртуальное окружение Python:

Примечание все следующие команды нужно выполнять из папки django-react и с активированным виртуальным окружением.

Установите зависимости Джанго и Django REST Framework:

pip install django djangorestframework

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

django-admin startproject django_react

Теперь сделаем API на Django для создания и хранения контактов.

Пишем приложение с бэкендом на Django

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

Для создания нового приложения Django используется команда:

django-admin startapp app_name

Django REST framework (обзор приложения Банк)

где app_name — название приложения.

В нашем случае команда будет выглядеть так:

django-admin startapp leads

Она создаст приложение leads в папке django-react . Теперь структура папок в проекте должна выглядеть так:

Теперь сделаем так, чтобы Django проект использовал новое приложение. Откройте файл django_react/settings.py и добавьте приложение в INSTALLED_APPS :

Создаём модель в базе данных с Джанго

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

Мы собираемся хранить контакты, поэтому модель Lead может состоять из этих полей:

Добавим ещё поле со временем создания модели, потому что по умолчанию Django этого не делает.

Откроем leads/models.py и опишем модель Lead :

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

Создадим миграции командой:

python manage.py makemigrations leads

и применим их к базе данных:

python manage.py migrate

Займёмся тестированием

Вы могли подумать «А как же тестирование?».

Существует масса туториалов по бэкенду на Джанго, начинающихся примерно так:

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

• встроенный код Django (модели, представления);
• встроенные функции Python.

Не тестируйте то, что уже протестировано! Так что же тогда тестировать?

Добавили свой метод в модель Django — протестируйте его. Дополнили стандартное представление — протестируйте его. Но как узнать, что именно нужно протестировать?

Узнать это поможет библиотека coverage. Установите её:

Django API + админка с нуля [за 10 минут]

pip install coverage

Теперь после каждого добавления или изменения кода запускайте coverage :

coverage run —source=’.’ manage.py test

и создавайте отчёт:

Вы увидите, что именно нужно протестировать. Если предпочитаете увидеть отчёт в командной строке, запустите команду:

Сериализаторы Django

Сериализация — это конвертация объекта Python в другой формат. После сериализации можно сохранить объект в файл или послать его через сеть.

Почему сериализация необходима? Модель Джанго — это класс Python. Чтобы превратить её в данные в формате JSON, нужна сериализация.

Сериализаторы работают и в обратном направлении: они конвертируют JSON в объекты. Это позволяет:

• отображать модель Django в браузере с помощью конвертации в JSON;
• делать запросы CRUD (create — read — update — delete) к API в формате JSON.

Суммируя: сериализаторы в Django можно использовать для совершения операций с моделями Django через API.

Создайте новый файл leads/serializers.py . Сериализатор LeadSerializer содержит нашу модель и поля:

Созданный дочерний класс от класса serializers.ModelSerializer . ModelSerializer в Django похож на ModelForm . Он подходит, когда нужно, чтобы сериализатор соответствовал модели.

Создаём представления

Если вы раньше работали с другими фреймворками, то можете удивиться, что в Django нет контроллеров.

Контроллеры содержат логику обработки запросов и возвращения ответов. В традиционной архитектуре MVC есть модель (Model), представление (View) и контроллер (Controller). Примеры MVC фреймворков: Rails (Ruby), Phoenix (Elixir), Laravel (PHP).

Django — это фреймворк MVT. MVT — это модель, представление и шаблон (Template). В Django есть много типов представлений: функции-представления, представления, основанные на классах, и обобщённые представления.

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

Мы будем использовать обобщённые представления. Наше простое приложение будет:

• возвращать выборку моделей;
• создавать новые объекты в базе данных.

С помощью документации можно узнать, что есть представление для возвращения выборки и создания моделей: ListCreateAPIView . Это представление содержит queryset и serializer_class .

queryset — это выборка данных, которую приложение будет возвращать. В нашем случае — все модели Lead . serializer_class — класс сериализатора для модели.

Добавьте в файл django_react/views.py следующий код:

С помощью трёх строк кода мы создали представление для обработки GET и POST запросов.

Чего ещё не хватает? Маршрутизации URL. Другими словами, нам нужно соединить URL и представления.

Настраиваем маршрутизацию url

Нам нужно сделать так, чтобы GET и POST запросы к api/lead/ обрабатывались представлением LeadListCreate , которое будет возвращать и создавать модели.

Чтобы настроить маршрутизацию URL, отредактируйте файл django_react/urls.py , добавив туда url приложения:

Так мы указываем в бэкенде на Django, что нужно использовать url, которые есть в приложения leads .

Теперь создайте файл leads/urls.py . В нём мы соединим представление LeadListCreate и url api/lead/ :

И наконец, включим rest_framework в INSTALLED_APPS . Откройте django_react/settings.py и добавьте приложение в INSTALLED_APPS :

Запустим сервер Django:

python manage.py runserver

Перейдите по url http://127.0.0.1:8000/api/lead/ и вы увидите API:

Примечание в продакшене лучше отключить возможность просмотра API. Это можно сделать в конфигурации:

Соединяем Django и React

У многих разработчиков возникают вопросы по поводу того, как правильно соединить Django и React.

Источник

Создайте REST API за 30 минут с помощью Django REST Framework

Прежде чем мы перейдем к коду, стоит подумать, зачем вам создавать API. Если бы кто-нибудь объяснил мне эти основные концепции до того, как я начал, мне было бы намного лучше.

REST API — это стандартизированный способ предоставления данных другим приложениям. Затем эти приложения могут использовать данные, как им заблагорассудится. Иногда API также предлагают другим приложениям возможность вносить изменения в данные.

Есть несколько ключевых вариантов запроса REST API:

• GET — Самый распространенный вариант, возвращает некоторые данные из API в зависимости от конечной точки, которую вы посещаете, и любых предоставленных вами параметров.
• POST — Создает новую запись, которая добавляется в базу данных
• PUT — Ищет запись по указанному вами URI. Если она существует, обновляет существующую запись. Если нет, создает новую запись
• DELETE — Удаляет запись по заданному URI
• PATCH — Обновляет отдельные поля записи

Обычно API — это окно в базу данных. Бэкэнд API обрабатывает запросы к базе данных и форматирует ответ. Вы получаете статический ответ любого запрошенного вами ресурса, обычно в формате JSON.

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

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

Процесс запроса и преобразования значений табличной базы данных в JSON или другой формат называется сериализацией. При создании API правильная сериализация данных является основной проблемой.

Почему Django REST Framework?

Самая большая причина использовать Django REST Framework заключается в том, что он упрощает сериализацию!

В Django вы определяете свои модели для своей базы данных с помощью Python. Хотя вы можете писать необработанный SQL, по большей части Django ORM обрабатывает все миграции и запросы базы данных.

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

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

Таким образом, Django REST Framework прекрасно работает с Django ORM, который уже выполняет всю тяжелую работу по запросам к базе данных. Всего несколько строк кода с использованием Django REST Framework, и вы можете сериализовать свои модели баз данных в форматы REST-ful.

Список пунктов для создания REST API в Django

Итак, исходя из того, что мы знаем, каковы шаги по созданию REST API?

1. Настроить Django
2. Создайте модель в базе данных, которой будет управлять Django ORM.
3. Сериализуйте модель из шага 2
4. Создайте конечные точки URI для просмотра сериализованных данных

Если это кажется простым, это потому, что это так. Поехали!

1. Настройка Django

Чтобы создать приложение Django, нам нужно установить Django. Это достаточно просто!

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

Вот видео этих шагов (но с другим названием проекта), если вы визуально обучаетесь: Видеурок «Создание Django приложения», Начинаем Django приложение правильно

1.1 Virtual Environment

Я использую pyenv и pyenv-virtualenv для своих сред:

1.2 Установка Django

Теперь мы можем установить Django:

Затем давайте начнем новый проект Django:

Если мы сейчас посмотрим на каталог, то увидим, что Django создал для нас новую папку:

И если мы заглянем в эту папку, там есть все, что нам нужно для запуска сайта Django:

Давай убедимся, что это работает. Тестовый запуск сервера Django:

Перейдите на localhost:8000 , и вы должны увидеть экран приветствия Django!

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

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

Итак, давайте создадим новое приложение для нашего API:

1.4 Зарегистрируйте приложение myapi в проекте mysite

Нам нужно сказать Django, чтобы он распознал это новое приложение, которое мы только что создали. Шаги, которые мы сделаем позже, не сработают, если Django не знает о myapi.

Итак, редактируем mysite/settings.py :

1.5 Перенести базу данных

Помните, как я сказал, что Django позволяет определять модели баз данных с помощью Python?

Каждый раз, когда мы создаем или вносим изменения в модель, нам нужно указать Django перенести эти изменения в базу данных. Затем Django ORM записывает для нас все команды SQL CREATE TABLE.

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

(Для тех из вас, кто думает: «Мы не создавали базу данных!». Вы правы. Но Django создаст для нас простую базу данных SQLite, если мы не укажем иное. И SQLite — это круто!)

Итак, давайте перенесем эти исходные модели:

1.6 Создать суперпользователя

Еще одна вещь, прежде чем мы продолжим.

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

Для этого нам потребуются учетные данные для входа. Итак, давайте сделаем себя владельцами и администраторами этого проекта. ВСЕМОГУЩЕГО СУПЕРПОЛЬЗОВАТЕЛЯ.

Убедимся, что это работает. Запустите сервер Django:

А затем перейдите на localhost:8000/admin

Войдите в систему со своими учетными данными суперпользователя, и вы должны увидеть панель администратора:

2. Создайте модель в базе данных, которой будет управлять Django ORM.

Сделаем нашу первую модель!

Мы создадим её в myapi/models.py , поэтому откройте этот файл.

2.1 myapi/models.py

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

name и alias — это символьные поля, в которых мы можем хранить строки. Метод __str__ просто сообщает Django, что печатать, когда ему нужно распечатать экземпляр модели Hero .

2.2 Сделайте миграции

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

2.3 Зарегистрируйте Hero на сайте администратора

Помните тот замечательный админский сайт, который поставляется прямо из коробки с Django?

Он не знает о существовании модели Hero , но с помощью двух строк кода мы можем сказать это о Hero .

Откройте myapi/admin.py и сделайте так:

Теперь запустим сервер Django:

Зайдите на localhost:8000/admin/ .

2.4 Создайте новых героев

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

Нажмите «Добавить» и создайте своих героев!

3. Настройте Django REST Framework.

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

Для этого нам понадобится Django REST Framework, так что давайте установим его.

Теперь скажите Django, что мы установили REST Framework в mysite/settings.py :

4. Сериализация модели героя

Теперь мы начинаем открывать новые горизонты. Нам нужно сообщить REST Framework о нашей модели Hero и о том, как она должна сериализовать данные.

Помните, сериализация — это процесс преобразования модели в JSON. Используя сериализатор, мы можем указать, какие поля должны присутствовать в JSON-представлении модели.

Сериализатор превратит наших героев в представление JSON, чтобы пользователь API мог их анализировать, даже если они не используют Python. В свою очередь, когда пользователь отправляет данные JSON в наш API, сериализатор преобразует этот JSON в модель Hero , чтобы мы могли сохранить или проверить.

Для этого создадим новый файл — myapi/serializers.py .

В этом файле нам необходимо:

1. Импортировать модель Hero
2. Импортировать сериализатор REST Framework
3. Создать новый класс, который связывает Hero с его сериализатором

5. Отображение данных

Теперь все, что осталось сделать, это подключить URL-адреса и представления для отображения данных!

5.1 Представления

Начнем с представления. Нам нужно отрендерить разных героев в формате JSON.

Для этого нам необходимо:

1. Запросить базу данных для всех героев
2. Передать этот набор запросов к базе данных в только что созданный сериализатор, чтобы он был преобразован в JSON и отображен.

ModelViewSet — это специальное представление, которое предоставляет Django Rest Framework. Он будет обрабатывать GET и POST для Heroe без дополнительной работы.

5.2 URL-адреса

Ладно, круто. Мы так близки. Последний шаг — указать URL-адрес только что созданной области просмотра.

В Django URL-адреса сначала разрешаются на уровне проекта. Итак, в каталоге mysite/ есть файл с именем urls.py .

Вы увидите, что URL-адрес сайта администратора уже присутствует. Теперь нам просто нужно добавить URL-адрес для нашего API. А пока давайте просто поместим наш API в индекс:

5.3 URL для API

Если вы обращаете внимание, а не просто копируете вслепую, вы заметите, что мы включили myapi.urls . Это путь к файлу, который мы еще не редактировали. И именно здесь Django будет искать инструкции по маршрутизации этого URL.

Итак, поехали дальше — myapi/urls.py :

Обратите внимание, что мы добавили кое-что под названием router , которое мы импортировали из rest_framework .

Маршрутизатор REST Framework будет следить за тем, чтобы наши запросы динамически попадали в нужный ресурс. Если мы добавим или удалим элементы из базы данных, URL-адреса обновятся, чтобы соответствовать. Круто, правда?

Маршрутизатор работает с viewset (смотрите views.py выше) для динамической маршрутизации запросов. Для того, чтобы маршрутизатор работал, он должен указывать на viewset , и в большинстве случаев, если у вас есть viewset , вы захотите, чтобы маршрутизатор работал с ним.

Пока что мы добавили в маршрутизатор только одну модель + сериализатор + набор просмотра — Heroes. Но мы можем добавить больше в будущем, повторяя тот же процесс, описанный выше, для разных моделей! (Может быть, в следующий раз создадим Villains API?)

Конечно, если вы хотите использовать только стандартные представления DRF вместо наборов представлений, urls.py будет выглядеть немного иначе. Для использования простых представлений маршрутизатор не нужен, их можно просто добавить с помощью:

Проверьте!

Снова запустите сервер Django:

Теперь перейдите на localhost:8000

Посетите конечную точку через GET

Если мы нажмем ссылку (гиперссылки — хороший REST-ful дизайн, кстати), мы увидим результаты API героев:

GET для индивидуального героя

Мы можем запросить с помощью GET единственный экземпляр модели, используя его ID.

viewsets представлений Django REST Framework позаботятся об этом за нас.

Если вы перейдете на 127.0.0.1:8000/heroes// , где — идентификатор одной из ваших моделей Героев, вы сможете увидеть только этого героя.

Например, http://127.0.0.1:8000/heroes/1/ для меня возвращает:

Мы можем сделать это немного более удобным, добавив ID в ответ heroes/ . В myapi/serializers.py измените список полей, включив «id»:

Теперь список героев выглядит так:

Мы можем использовать эти идентификаторы для поиска отдельных моделей.

Отправить запрос POST

Наш API также обрабатывает POST запросы. Мы можем отправить JSON в API, и он создаст новую запись в базе данных.

Теперь в нашем API есть Капитан Америка!

Быстрые API REST с Django REST Framework

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

Тем не менее, вы хорошо продвигаетесь с этим постом. REST Framework довольно хорошо справляется со сложностью. Если вы застряли, есть отличное сообщество, готовое помочь вам найти решение.

Источник

Создаем API блога на Django REST Framefork

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

Django REST Framework — это набор инструментов для создания REST API с помощью Django. В этом руководстве рассмотрим, как правильно его использовать. Создадим эндпоинты(точки доступа к ресурсам) для пользователей, постов в блоге, комментариев и категорий.

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

Вот чему вы научитесь:

• Добавлять новые и существующие модели Django в API.
• Сериализовать модели с помощью встроенных сериализаторов для распространенных API-паттернов.
• Создавать представления и URL-паттерны.
• Создавать отношения многие-к-одному и многие-ко-многим.
• Аутентифицировать пользовательские действия.
• Использовать созданный API Django REST Framework.

Требования

У вас в системе должен быть установлен Python 3, желательно 3.8. Также понадобится опыт работы с REST API. Вы должны быть знакомы с реляционными базами данными, включая основные и внешние ключи, модели баз данных, миграции, а также отношения многие-к-одному и многие-ко-многим.

Наконец, потребуется опыт работы с Python и Django.

Настройка проекта

Для создания нового API-проекта для начала создайте виртуальную среду Python в своей рабочей директории. Для этого запустите следующую команду в терминале:

В Windows это будет source envScriptsactivate .

Не забывайте запускать все команды из этого руководства в виртуальной среде. Убедиться в том, что она активирована можно благодаря надписи ( env ) в начале строки приглашения к вводу в терминале.

Чтобы деактивировать среду, введите deactivate .

После этого установите Django и REST Framework в среду:

Создайте новый проект «blog» и новое приложение «api»:

Из корневой директории «blog» (там где находится файл «manage.py»), синхронизируйте базу данных. Это запустит миграции для admin , auth , contenttypes и sessions .

Вам также понадобится пользователь admin для взаимодействия с панелью управления Django и API. Из терминала запустите следующее:

Установите любой пароль (у него должно быть как минимум 8 символов). Если вы введете слишком простой пароль, то можете получить ошибку.

Для настройки, добавьте rest_framework и api в файл конфигурации (blog/blog/settings.py):

Добавление ApiConfig позволит добавлять параметры конфигурации в приложение. Другие настройки для этого руководства не потребуются.

Наконец, запустите локальный сервер с помощью команды python manage.py runserver .

Перейдите по ссылке http://127.0.0.1:8000/admin и войдите в админ-панель сайта. Нажмите на «Users», чтобы увидеть пользователя и добавить новых при необходимости.

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

Теперь с пользователем «admin» можно переходить к созданию самого API. Это предоставит доступ только для чтения списку пользователей из списка API-эндпоинтов.

Сериализатор для User

REST Framework Django использует сериализаторы, чтобы переводить наборы запросов и экземпляры моделей в JSON-данные. Сериализация также определяет, какие данные вернет API в ответ на запрос клиента.

Пользователи Django создаются из модели User , которая определена в django.contrib.auth . Для создания сериализатора для модели добавьте следующее в blog/api/serializers.py (файл нужно создать):

По примеру импортируйте модель User из Django вместе с набором сериализаторов из REST Framework Django.

Теперь создайте класс UserSerializer , который должен наследоваться от класса ModelSerializer .

Определите модель, которая должна ассоциироваться с сериализатором (model = User). Массив fields определяет, какие поля модели должны быть включены. Например, можно добавлять поля first_name и last_name .

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

Этот сериализатор также создает простые методы create() и update() . При необходимости их можно переписать.

Ознакомиться подробнее с работой ModelSerializer можно на официальном сайте.

Представления для User

Есть несколько способов создавать представления в REST Framework Django. Чтобы получить возможность повторного использования кода и избегать повторений, используйте классовые представления.

REST Framework предоставляет несколько обобщенных представлений, основанных на классе APIView . Они представляют собой самые распространенные паттерны.

Например, ListAPIView используется для эндпоинтов с доступом только для чтения. Он предоставляет метод-обработчик get . ListCreateAPIView используется для эндпоинтов с разрешением чтения-записи, а также обработчики get и post .

Для создания эндпоинта только для чтения, который возвращал бы список пользователей, добавьте следующее в blog/api/views.py:

В первую очередь здесь импортируется generics коллекция представлений, а также модель User и UserSerialized из предыдущего шага. Представление UserList предоставляет доступ только для чтения (через get ) к списку пользователей, а UserDetails — к одному пользователю.

Названия представлений должны быть в следующем формате: List и Details для коллекции объектов и одного объекта соответственно.

Для каждого представления переменная queryset содержит коллекцию экземпляров модели, которую возвращает User.objects.all() . Значением serializer_class должно быть UserSerializer , который и сериализует данные модели User .

Пути к эндпоинтам будут настроены на следующем шаге.

URL-паттерны

С моделью, сериализатором и набором представлений для User финальным шагом будет создание эндпоинтов (которые в Django называются URL-паттернами) для каждого представления.

В первую очередь добавьте следующее в blog/api/urls.py (этот файл тоже нужно создать):

Здесь импортируется функция path и также коллекция представлений приложения api .

Функция path создает элемент, который Django использует для показа страницы приложения. Для этого Django в первую очередь ищет нужный элемент с соответствующим URL (например, users/ ) для запрошенного пользователем. После этого он импортирует и вызывает соответствующее представление (то есть, UserList )

Последовательность указывает на целочисленное значение, которое является основным ключом ( pk ). Django захватывает эту часть URL и отправляет в представление в виде аргумента-ключевого слова.

В этом случае основным ключом для User является поле id , поэтому http://127.0.0.1:8000/users/1 вернет id со значением 1 .

Прежде чем можно будет взаимодействовать с этими URL-паттернами (и теми, которые будут созданы позже) их нужно добавить в проект. Добавьте следующее в blog/blog/urls.py:

Чтобы убедиться, что все элементы работают корректно, перейдите по ссылке http://127.0.0.1:8000/users, чтобы увидеть список пользователей приложения.

В этом руководстве используется графическое представление API из Django REST Framework для демонстрации эндпоинтов. Интерфейс предоставляет элементы аутентификации и формы, имитирующие фронтенд-клиент. Для тестирования API также можно использовать cURL или httpie.

Обратите внимание на то, что значение пользователя admin равно 1 . Можете перейти к нему, открыв для этого http://127.0.0.1:8000/users/1.

В итоге класс модели Django сериализуется с помощью UserSerializaer . Он предоставляет данные представлениям UserList и UserDetail , доступ к которым можно получить с помощью паттернов users/ и users/ .

Создание API для Post

После базовой настройки можно приступать к созданию полноценного API для блога с эндпоинтами для постов, комментариев и категорий. Начнем с API для Post.

Модель Post

В blog/api/models.py создайте модель Post , которая наследуется от класса Model из Django и определите ее поля:

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

Обратите внимание на то, что тип ForeignKey создает отношение многие-к-одному между текущей моделью и моделью, указанной в первом аргументе ( auth.User — то есть, модель User , с которой вы работаете).

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

Аргумент related_name позволяет задать другое имя доступа к текущей модели ( posts ) вместо стандартного ( post_set ). Список постов будет добавлен в сериализатор User на следующем шаге для завершения отношения многие-к-одному.

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

Поскольку мы работаем с моделями Django, таким как User , посты можно изменить из административной панели Django, зарегистрировав ее в blog/api/admin.py:

Позже их можно будет создавать и через графическое представление API.

Перейдите на http://127.0.0.1:8000/admin, кликните на Posts и добавьте новые посты. Вы заметите, что поля title и body в форме соответствуют типам CharField и TextField из модели Post .

Также можно выбрать owner среди существующих пользователей. При создании поста в API пользователя выбирать не нужно. Owner будет задан автоматически на основе данных залогиненного пользователя. Это настроим в следующем шаге.

Сериализатор Post

Чтобы добавить модель Post в API, нужно повторить шаги добавления модели User .

Сначала нужно сериализовать данные модели Post . В blog/api/serializers.py добавьте следующее:

Импортируйте модель Post из приложения api и создайте PostSerializer , который будет наследоваться от класса ModelSerializer . Задайте модель и поля, которые будут использоваться сериализатором.

ReadOnlyField — это класс, возвращающий данные без изменения. В этом случае он используется для возвращения поля username вместо стандартного id .

Дальше добавьте поле posts в UserSerializer . Отношение многие-к-одному между постами и пользователями определено моделью Post в прошлом шаге. Название поля ( posts ) должно быть равным аргументу related_field поля Post.owner . Замените posts на post_set (значение по умолчанию), если вы не задали значение related_field в прошлом шаге.

PrimaryKeyRelatedField представляет список публикаций в этом отношении многие-к-одному ( many=True указывает на то, что постов может быть больше чем один).

Если не задать read_only=True поле posts будет иметь права записи по умолчанию. Это значит, что будет возможность вручную задавать список статей, принадлежащих пользователю при его создании. Вряд ли это желаемое поведение.

Перейдите по ссылке http://127.0.0.1:8000/users, чтобы увидеть поле posts каждого пользователя.

Обратите внимание на то, что список posts — это, по сути, список id. Вместо этого можно возвращать список URL с помощью HyperLinkModelSerializer .

Представления Post

Следующий шаг — создать набор представлений для Post API. Добавьте следующее в blog/api/views.py:

Источник

Создание Django API используя Django Rest Framework часть 1

API (Application Programming Interface — интерфейс прикладного программирования) — это программное обеспечение, которое позволяет двум приложениям общаться друг с другом. В серии статей будет показано как создать API, которое позволит создавать, читать, редактировать и удалять статьи, в нашем тестовом блоге. Это будет проект имитирующий блог у которого должно быть серверное API.

Мы рассмотрим различные способы создания API на базе библиотеки Django Rest Framework (DFR). Серия будет состоять из 3 частей. В первой статье мы рассмотрим использование простого класса APIView (часть 1), во второй использования более расширененного класса GenericAPIView (часть 2) и, наконец в третьей использования пожалуй самого продвинутого класса ViewSets (часть 3). Так как мы всего лишь сравниваем применение этих трех классов то обзоры будут короткие и мы не будет подробно рассматривать все возможности выше упомянутых классов.

Итак, приступим. Начнем с установки Django и Django Rest Framework. В терминале создайте каталог и дайте ему любое описательное имя; Затем перейдите в созданный каталог и установите Django, набрав:

Так как мы будем использовать Django Rest Framework (DRF) для создания API, установите и его, так же, как мы делали это выше.

Теперь все готово что бы создать наш первый DRF API.

Для этого нам нужно создать проект Django для работы. Для этого мы запустим следующую команду:

Затем запустить миграцию базы данных. Таким образом будет создана база данных по умолчанию (на sqlite), со всеми требуемыми таблицами. Запустите команду:

Теперь можно запустить сервер, чтобы убедиться, что все в порядке:

Сейчас у нас есть проект Django, в который мы можем интегрировать Django rest framework. Откройте файл settings.py и добавьте в атрибут установленных приложениях INSTALLED_APPS = […] строку rest_framework в кавычках.

Далее приступим к созданию приложения для нашего проекта. Мы создадим приложение article, в котором мы разместим все, что связано со статьями.

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

Затем перейдите к файлу models.py. В нем, мы создадим наши модели.

Начнем с создания модели авторов:

Затем ниже создадим модель статей:

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

Далее, создадим пользователя с правами администратора:

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

Теперь можно снова запустить сервер и зайти на страницу админки http://127.0.0.1:8000/admin/login/
Далее нужно ввести учетные данные администратора и мы попадем в приложение Django administration.

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

Теперь наша админка должна выглядеть как то так:

Пришло время создать наше API.
Мы начнем с метода через которого можно просмотреть все статьи. Для этого откройте файл article/views.py и вставьте следующий код

Далее нам нужно создать URL-адрес, с которого пользователь сможет получить доступ к этому методу. Для этого создайте файл article/urls.py . В этом файле вставьте следующий код.

Далее нам нужно включить эти URL-адреса в основной файл URL-адресов test_django/urls.py

Чтобы включить наши URL из приложения articles в основную конфигурацию URL, мы будем использовать метод include Django. Откройте файл test_django/urls.py, отредактируйте следующим образом:

Теперь каждый раз, когда мы будем заходить по адресу http://127.0.0.1:8000/api/articles/ , мы получим доступ ко всем URL-адресам, которые мы определяем внутри articles/urls.py .

Теперь у нас метод API через который мы можем просматривать все статьи в базе данных.

В настоящее время в нашей базе данных нет статей, поэтому мы получаем пустой список. Одной из причин, по которой мы добавили наши модели Article и Author на страницу администратора, была возможность добавлять авторов и статьи непосредственно в нашу базу данных через приложение администратора.

Теперь давайте создадим новые объекты в таблице Author и Article в приложение администратора.

После добавления одного и более автора и статьи, вы может заметить что их отображение не совсем так как хотелось бы

Article object(1) не особо информативное отображение имени объекта. Давай те изменим это, добавим отображение имени статьи. Для этого вернемся в наш article/models.py и добавим метод __str__ Этот метод даст нам удобочитаемое отображение объектов Article .

После добавления этого метода в класс Article , наша админка будет выглядеть как то так:

Добавьте такой же метод в класс Author .

Теперь у нас должно быть несколько статей в таблице Articles , проверим работает ли доступ API к статьям. Перейдите по адресу http://127.0.0.1:8000/api/articles

TypeError. Серьезно? После всего того что мы сделали?
Ошибка возникла в строке return Response() где мы пытаемся сериализовать (то есть сконвертировать из объектов в формат JSON) список объектов articles . Но так как мы еще не указали класс для сериализации объектов статей, мы получили ошибку.

Чтобы это исправить, познакомимся с понятием Serializers .

Serializers (Сериализаторы) позволяют преобразовывать сложные данные, такие как наборы запросов querysets и объекты моделей, в типы данных Python, которые затем можно легко преобразовать в JSON, XML или другие content types.

Теперь, давайте создадим сериалайзер, который преобразует наши статьи в список Python, который мы можем вернуть в API запросе.
Создайте новый файл в папке статей и назовите его что-то вроде article/serializers.py. В этот файл добавьте следующий код:

Как вы можете видеть, мы пока еще не сериализуем автора (author). Мы это сделаем позже.
Следующий шаг — нужно добавить этот сериализатор в наши представления (views) и сделать так чтобы представление сериализовало статьи. Следующий код показывает, как это делается.

После этого снова запустите сервер и перейдите к http://127.0.0.1:8000/api/articles/ . Должно получится что то типа такого:

Далее добавим метод API для создание статьи. Можно было бы создать еще один класс с методом post и зарегистрировать его в URL-адресах так же, как мы делали для метода get. Однако вместо создания нового класса, воспользуемся тем что APIView позволяет нам указать несколько HTTP-методов для одного класса. Поэтому добавим метод post внутри нашего ArticleView .

Как видите, мы используем созданный ранее сериализатор, чтобы создать новый объект статьи из данных которые мы получаем от пользователя. Как мы уже говорили ранее, мы проигнорировали поле автора в нашем сериализаторе, и поэтому оно не возвращается в полученном ответе. Чтобы мы могли использовать наш сериализатор для создания статей, нам нужно добавить поле author_id в сериализатор, а затем нам потребуется реализовать метод create в сериализаторе, который сообщит сериализатору, что делать, когда вызывается метод save сериализатора.
Обновим наш ArticleSerializer , чтобы он выглядел следующим образом.

Учитывая, что мы создали автора с панели администратора, теперь вы можете использовать postman или любой другой REST клиент для создания статьи (например какой нибудь REST плагин в хроме). Пример такого запроса показан ниже.

Благодаря этому каждый теперь сможет создавать статьи используя API. Теперь создадим возможность редактирования статьи.

Для этого мы обновим API articles , чтобы пользователи могли обновить статью, отправив запрос PUT. Сначала добавим новый path в файл article/urls.py.

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

Что происходит в методе update ? В том случае если мы что то передаем в экземпляр статьи, который мы хотим обновить, мы переназначаем это значение, в противном случае мы сохраняем старое значение атрибута.

Теперь создадим обработку запроса на обновление статьи. Мы должны определить метод put в нашем ArticleView , этот метод должен принять параметр pk из URL, найти требуемый экземпляр из базы и запустить сериалайзер на обновление. Внесем соотвествующие изменения в файл article.views.py.

Мы передаем partial=True в сериализатор, поскольку хотим иметь возможность обновлять только некоторые поля, но не обязательно все сразу.
Используя Postman или любой другой инструмент, теперь можно обновить статью, отправив запрос по адресу http://127.0.0.1:8000/articles/ с данными, которые вы хотите обновить.

Последнее что нам осталось добавить для создания полноценного CRUD API, это метод удаления. Для этого мы создадим метод delete в APIView , который будет принимать id статьи, в качестве аргумента.

В методе delete все, что мы делаем — это получаем статью из базы, и если она существует, удаляем ее и затем возвращаем ответ пользователю.

Теперь у нас есть полностью функционирующие API, с помощью которого мы можем выполнить все основные задачи API, т. е. Операции Create Read Update Delete (CRUD).

Во второй части этой серии мы рассмотрим, как использовать Django Rest Framework GenericAPIView.

Источник

Разработка RESTful-интерфейсов при помощи Python, Django и Django REST Framework

Эта статья является исчерпывающим руководством для начинающих программистов, желающих разрабатывать проекты с RESTful интерфейсами, используя при этом Python, Django и Django Rest Framework.

Введение

— это веб-фреймворк, написанный на Python.
• Python — это высокоуровневый интерпретируемый язык программирования общего назначения.
• API (Application Programming Interface, интерфейс приложения) — это набор правил и механизмов, посредством которых приложение или его части взаимодействуют с другими приложениями.
• REST (Representational State Transfer) — это программная архитектура интерфейсов REST.

Как сказано в диссертации Роя Филдинга: «REST — это архитектурный стиль, который в основном использует существующие технологии и протоколы интернета. Попросту говоря, это представление данных для клиента в подходящем для него формате.»

Следовательно, RESTful + API (интерфейс) является широко используемой терминологией для реализации такой архитектуры и связанных с ней ограничений (например, в веб-сервисах).

Вот пример запроса GET из интерфейса Github:

Вы получите примерно следующее:

Получен набор данных в формате JSON.

JSON ( JavaScript Object Notation) — это открытый файловый формат, в котором обычный текст используется для передачи объектов данных, состоящих из пар атрибут-значение и типов данных массива. Конечно, существуют и другие форматы, такие как XML, INI, CSV и так далее. Но на сегодняшний день, JSON, благодаря своей интуитивной и понятной структуре, применяется крайне широко вне зависимости от того, какой язык программирования используется.

Python и Django

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

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

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

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

Краткий обзор Django

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

Возьмем пользовательскую модель User :

Если в вашу модель были внесены какие-либо изменения, запустите модуль makemigrations .

Затем вы можете синхронизировать базу данных с набором моделей и миграций.

Создание REST интерфейсов при помощи Django Rest Framework

Django REST Framework (DRF) — это мощный и гибкий инструмент для создания веб-интерфейсов (web APIs). Он дает возможность разработчикам не изобретать колесо, самостоятельно создавая сложный и громоздкий REST-интерфейс с нуля. Чем сложнее будут становиться ваши проекты, тем лучше вы будете осознавать необходимость использования DRF или других полезных REST-фреймворков.

1. Инсталляция и настройка проекта

Создаем директорию проекта

Устанавливаем пакет virtualenv при помощи pip.

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

pip это менеджер пакетов. С его помощью можно устанавливать пакеты, написанные на языке Python, и далее управлять ими.

Создаем папку виртуального окружения в директории нашего проекта.

Активируем виртуальное окружение.

Чтобы отменить изменения, просто запустите команду deactivate . Подробнее об этом — в документации virtualenv.

Устанавливаем библиотеки django, djangorestframework.

Создаем наш проект в django.

Запускаем наш проект.

Непримененными миграциями (unapplied migration(s)) являются файлы, включенные при создании проекта django.

Чтобы их синхронизировать, просто запустите команду migrate .

В качестве базы данных нашего проекта установлена SQLite база данных под названием db.sqlite3 .

Создаем приложение в нашем проекте.

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

2. Модель

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

Метод __str__ вызывается при помощи встроенной функции str() , а также при выполнении инструкции print() для вычисления неформального строкового представления объекта.

Если вы сейчас запустите команду makemigrations , Django пока никаких изменений не заметит.

Чтобы решить эту проблему, нужно в файле setting.py добавить наше приложение post в список установленных приложений.

Теперь можно применить миграцию.

3. Сериализация

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

Создадим файлы serializers.py и views.py и разместим их следующим образом:

В нашем руководстве мы используем класс ModelSerializer , более подробно о нем можно прочитать в документации.

4. Представления (views)

Функция представления, или для краткости просто представление, является функцией Python. Она принимает на вход веб-запрос и возвращает ответ.

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

В данном отрывке кода мы использовали методы представлений из класса generics , который находится в модуле rest_framework . Более подробно о них можно прочитать в документации.

5. URLs

Здесь мы настраиваем наши маршруты или URL-пути к нашим представлениям, от которых мы ожидаем определенных ответов на каждый запрос.

6. Завершаем настройку

Давайте убедимся, что модуль rest_framework добавлен в список приложений нашего проекта.

7. Админка Django

Так как мы пока не настроили наши POST-запросы, будем пополнять нашу базу данных через панель администратора Django.

Для этого создадим аккаунт admin с паролем 1234password и правами супеюзера.

Теперь зарегистрируем модель Post в панели администратора.

Вот и все. Теперь зайдите в панель администратора и обновите записи в модели Post. Более подробно об этом можно прочитать в документации.

8. Тестируем наш интерфейс (API)

Великолепно! Теперь настало время обновить наши представления и на этом закончить со стандартными CRUD-операциями.

9. Добавляем новые представления (views)

POST — это метод, используемый для создания новых ресурсов в нашей базе данных либо для обновления старых.

Когда мы хотим передать список данных, тем самым предотвращая соответствующий POST-запрос, или создаем запись в базе данных для конкретного представления списка, то, как правило, мы разделяем классы представлений List и Create .

Варианты использования для разных приложений всегда разнятся, для объединения логики набора связанных представлений вы вольны использовать ListCreateAPIView или даже ViewSets.

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

Добавим дополнительные представления с методами GET , PATCH , и DELETE .

10. Обновление URL

Теперь мы можем отправлять запросы к нашему API через Postman , наше приложение, или делать GET-запросы из нашего браузера. Например:

Источник