[PYTHON] Créer une API REST pour faire fonctionner dynamodb avec le Framework Django REST

introduction

Créez une API qui fonctionne sur DynamoDB sur AWS avec django REST Framework et boto3. Activez les opérations GET, POST, PUT et DELETE.

Création de table Dynamodb (préparation)

Préparez à l'avance un tableau comme celui ci-dessous et mettez-y des données. Nom de la table: Fruits hash key: Name

Créer un projet django

Créer un projet django (dynamo_operation) et une application (api)

$ django-admin startproject dynamo_operation
$ cd dynamo_operation/
$ django-admin startapp api 

Modifier setting.py

Ajoutez la configuration rest_framework et ʻapp créée précédemment à setting.py`.

dynamo_operation/setting.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework', #ajouter à
    'api.apps.ApiConfig', #ajouter à
]

Créer un modèle pour la requête DynamoDB

Dans django, model est préparé pour la création et le fonctionnement de la base de données. Puisque la requête à DynamoDB utilise boto3, model n'est pas nécessaire, mais cette fois nous avons préparé model (dynamo_model.py).

api/dynamo_model.py

class Fruit():
    def __init__(self, name):
        self.name = name

Modifier views.py

api/views.py

from rest_framework import status
from rest_framework.views import APIView
from rest_framework.response import Response 
from api.dynamo_models import Fruit
from boto3 import client

dynamodb_client = client('dynamodb')

class DynamoRequest(APIView):
    #ENTIER OBTENIR
    def get(self, request):
        response = []
        items = dynamodb_client.scan(TableName='Fruits')['Items']
        for item in items:
            fruit = Fruit(item['Name']['S'])
            fruit.price = item.get('Price',{}).get('N', '')
            response.append(fruit.__dict__)
        return Response(response)
    
    def post(self, request):
        request_data = request.data
        item = {'Name': {'S': request_data['Name']}}

        if 'Price' in request_data:
            item['Price'] = {'N': request_data['Price']}

        dynamodb_client.put_item(
            TableName = 'Fruits',
            Item = item
        )
        return Response(status=status.HTTP_201_CREATED)


class DynamoDetailRequest(APIView):
    #GET unique
    def get(self, request, pk):
        item = dynamodb_client.get_item(
            TableName = 'Fruits',
            Key = {
                'Name': {'S': pk},
            }
        )['Item']
        fruit = Fruit(item['Name']['S'])
        fruit.price = item.get('Price',{}).get('N', '')
        return Response(fruit.__dict__)
    
    def put(self, request, pk):
        request_data = request.data

        item = dynamodb_client.get_item(
            TableName = 'Fruits',
            Key = {
                'Name': {'S': pk},
            }
        )['Item']

        price = item.get('Price',{}).get('N', '0')

        if 'Price' in request_data:
            price = request_data['Price']

        dynamodb_client.put_item(
            TableName = 'Fruits',
            Item = {
                'Name': {'S': item['Name']['S']},
                'Price': {'N': price}
            }
        )
        return Response(status=status.HTTP_200_OK)
    
    def delete(self, request, pk):
        dynamodb_client.delete_item(
            TableName = 'Fruits',
            Key = {
                'Name': {'S': pk},
            }
        )
        return Response(status=status.HTTP_204_NO_CONTENT)

Traitez la requête avec class qui hérite de ʻAPIView de rest_framework. DynamoRequest gère la demande sans le paramètre de chemin, etDynamoDetailRequest gère la demande avec le paramètre de chemin (pk). En héritant de ʻAPIView, il est possible d'ajouter des traitements correspondant à chaque méthode en préparant une fonction pour chaque méthode HTTP.

Modification de urls.py

api/urls.py

from django.urls import path
from api import views

urlpatterns = [
    path('api/', views.DynamoRequest.as_view()),
    path('api/<pk>/', views.DynamoDetailRequest.as_view())
]

Modifiez également ʻurls.pydans le dossierdynamo_opration`

dynamo_opration/urls.py

from django.urls import path, include

urlpatterns = [
    path('', include('api.urls')),
]

Vérifier le fonctionnement avec la commande curl

démarrer le serveur

$ python manage.py runserver

GET (recherche complète)

$ curl http://127.0.0.1:8000/api/

#réponse
[{"name":"orange","price":"200"},{"name":"banana","price":"100"},{"name":"apple","price":"100"}]

POST

$ curl -X POST \
  -H 'Content-Type:application/json' \
  -d '{"Name": "peach", "Price": "400"}' \
  http://127.0.0.1:8000/api/

Table après requête POST

L'élément pêche a été ajouté.

GET (single)

Obtenir un article Apple

$ curl http://127.0.0.1:8000/api/apple/

#réponse
{"name":"apple","price":"100"}

PUT Changer le prix de la pomme de 100-> 200

$ curl -X PUT \
  -H 'Content-Type:application/json' \
  -d '{"Price": "200"}' \
  http://127.0.0.1:8000/api/apple/

Tableau après demande PUT

DELETE Supprimez l'élément pêche.

$ curl -X DELETE http://127.0.0.1:8000/api/peach/

Tableau après la demande DELETE

en conclusion

J'ai créé une API REST qui exploite DynamoDB avec django REST Framework + boto3. Cette fois, j'ai préparé dynamodb_model.py pour gérer le modèle, mais cela n'a peut-être pas été nécessaire (j'aimerais améliorer la conception ici à l'avenir).