¿Qué es y como crear un API REST en Django?
Clase 40 de 58 • Curso de Python y Django 2015
Contenido del curso
Fundamentos
- 2

¿Qué significa ser un Backend?
00:00 min - 3

El papel del Backend en el desarrollo de un proyecto
02:26 min - 4

La alegría de ser un backend
00:00 min - 5

¿Cómo funciona una aplicación web?
00:00 min - 6

¿Por qué Django?
01:03 min - 7

Introducción a Python: Conoce las bases del Lenguaje
05:25 min - 8

Django: Bases del framework web mas popular de Python
04:14 min
Introducción a Python y Django
- 9

Aprende Python y preparate para Django
70:14 min - 10

Conoce tu primer proyecto en Django: Sfotipy
23:20 min - 11

Creación de módulos para nuestro proyecto Sfotipy
33:35 min - 12

Sesión de preguntas y respuestas
21:30 min - 13

Configura y crea un primer proyecto de Django
03:37 min - 14

Repositorio del Proyecto: Sfotipy
00:04 min
Vistas, Modelos y Formularios en Django
- 15

Administrador de Django, creación de modelos y de vistas
45:32 min - 16

Uso y manejo de formularios en Django
62:49 min - 17

Sesión de preguntas y respuestas
17:45 min - 18

Las mejores prácticas en Django
00:00 min - 19

Creación de modelos en Django y su implementación en vistas
02:17 min - 20

Activa el administrador de Django en tres líneas de código
00:33 min - 21

Templates en Django: Renderizar no es complicado
02:15 min - 22

Integración del Frontend y del Backend cuando usamos Django
00:41 min
Admin Avanzando, Middlewares y Class Based Views
- 23

Django Revolutions
65:48 min - 24

Django Revolutions Parte 2
55:29 min - 25

Sesión de preguntas y respuestas
04:31 min - 26

Personalizar el administrador de Django
04:51 min - 27

¿Que es Unit Testing?
01:00 min - 28

Middlewares en Django
01:16 min - 29

Class-Based Views
00:44 min - 30

¿Cómo usar Unit Testing en Django?
01:00 min - 31

Context Processors en Django
01:14 min - 32

Caching
01:35 min
Creación de un API REST en Django
- 33

Creando un API REST en Django
42:10 min - 34

Archivos Estáticos
22:25 min - 35

Manejo de Cache en Django
36:04 min - 36

Manejo de Imágenes
11:00 min - 37

Procesos Asíncronos
16:29 min - 38

Sesión de preguntas y respuestas
16:21 min - 39

Bonus: servidores y deploy con Django
49:42 min - 40

¿Qué es y como crear un API REST en Django?
Viendo ahora - 41

Archivos Estáticos
01:15 min - 42

Optimizando.la
01:24 min - 43

Procesos Asíncronos: Celery y un poco de Redis
03:16 min
Django Avanzado: Introducción a Class-based Views
Django avanzado: ListView, JsonResponse y Mixins
Django Avanzado: Vistas avanzadas y Migraciones
Las APIS REST están basadas en el “Representational State Transfer” que es un tipo de arquitectura de desarrollo web apoyada en HTTP.
Por esta razón las APIs utilizan los métodos de HTTP (GET, POST, PUT, DELETE). Éstas se usan para ejecutar operaciones con los datos de tu aplicación.
“Lo más importante de las APIs son los recursos!”
Métodos
GET: Consultar y leer recursos POST: Crear recursos PUT: Editar recursos DELETE: Eliminar recursos
Ventajas
¿Para qué usar las APIs REST?
- Exponer datos a otros programas
- Facilitar el desarrollo del frontend
- Crear arquitecturas orientadas a servicios
Crear una API REST
Para crear un API RESTful, Django nos ofrece un framework con características mágicas llamado Django Rest Framework (http://django-rest-framework.org/) que debemos instalar en nuestra aplicación.
Para desarrollar APIs REST hay que tener claro que los métodos HTTP son fundamentales.
1. Para usar los datos de la aplicación en una APIs Rest deben serializarse; en la carpeta de la aplicación se crea un archivo serializer.py (standar).
**2. **Importamos a serializer.py, del framework de REST los serializers y también importamos los modelos de los cuales se van a serializar los datos
<pre class="prettyprint">from rest_framework import serializers from .models import _modelos_</pre>**3. **Se crean las clases que heredan de “serializers.HyperlinkedModelSerializer” y en ellas se van a definir de los modelos, los cuales son los datos que se quieren serializar
Ej.
<pre class="prettyprint">class EnlaceSerializer(serializers.HyperlinkedModelSerializer): class Meta: model = Enlace fields = ('url', 'titulo','enlace','votos','usuario','timestamp',)</pre>**4. **Crear las vistas para los serializadores en views.py, estas vistas heredan de viewsset de rest_framework. Para esto se deben importar los serializers y los viewset.
Ej.
<pre class="prettyprint">from .serializers import EnlaceSerializer, UserSerializer from rest_framework import viewsets class EnlaceViewSet(viewsets.ModelViewSet): queryset = Enlace.objects.all() serializer_class = EnlaceSerializer </pre>**5. **Crear las urls, para esto se usa la clase Router de rest_framework.
El uso de la clase Router es debido a que se usan ViewSets. Utilizando la clase Router puedes manejar de forma automática la conexión entre los recursos en las vistas y las urls. Todo lo que hay que hacer es registrar las vistas en un router, y dejar que haga el resto.
Ej.
<pre class="prettyprint">from rest_framework import routers from app.views import EnlaceViewSet router = routers.DefaultRouter() router.register(r'links', EnlaceViewSet) urlpatterns = patterns('', url(r'^api/', include(router.urls)), url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')), )</pre>**6. **Instalas el ‘rest_framework’ a las aplicaciones de tu proyecto en settings.py y listo vas a la url de tu API REST y tienes lista tu API para usarla.
Nota: Chrome como buen aliado del desarrollo Web tiene una extensión que te ayuda a administrar los recursos de tu API → REST Console.
(https://chrome.google.com/webstore/detail/rest-console/cokgbflfommojglbmbpenpphppikmonn)
En https://www.djangopackages.com/grids/g/rest/ encontrarás paquetes que te ayudan a construir APIs REST.