[PYTHON] Erstellen Sie eine REST-API, um dynamodb mit dem Django REST Framework zu betreiben

Einführung

Erstellen Sie eine API, die mit DynamoDB unter AWS mit django REST Framework und boto3 ausgeführt wird. Aktivieren Sie die Operationen GET, POST, PUT und DELETE.

Dynamodb-Tabellenerstellung (Vorbereitung)

Bereiten Sie im Voraus eine Tabelle wie die folgende vor und geben Sie einige Daten ein. Tabellenname: Früchte hash key: Name

Erstellen eines Django-Projekts

Erstellen Sie ein Django-Projekt (dynamo_operation) und eine App (api).

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

Bearbeiten Sie settings.py

Fügen Sie rest_framework und die zuvor erstellte app-Konfiguration zu settings.py hinzu.

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', #hinzufügen
    'api.apps.ApiConfig', #hinzufügen
]

Modell für DynamoDB-Anforderung erstellen

In Django wird "Modell" für die Erstellung und den Betrieb der Datenbank vorbereitet. Da die Anfrage an DynamoDB boto3 verwendet, ist model nicht erforderlich, aber diesmal haben wir model (dynamo_model.py) vorbereitet.

api/dynamo_model.py

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

Views.py bearbeiten

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):
    #Ganz GET
    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):
    #Single GET
    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)

Verarbeiten Sie die Anfrage mit class, die APIView von rest_framework erbt. DynamoRequest behandelt die Anfrage ohne den Pfadparameter undDynamoDetailRequest behandelt die Anfrage mit dem Pfadparameter (pk). Durch das Erben von "APIView" ist es möglich, die jeder Methode entsprechende Verarbeitung hinzuzufügen, indem für jede HTTP-Methode eine Funktion vorbereitet wird.

Bearbeiten von 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())
]

Bearbeiten Sie auch urls.py im Ordner dynamo_opration

dynamo_opration/urls.py

from django.urls import path, include

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

Überprüfen Sie die Funktion mit dem Befehl curl

Server starten

$ python manage.py runserver

GET (ganze Suche)

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

#Antwort
[{"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/

Tabelle nach POST-Anfrage

Der Pfirsichartikel wurde hinzugefügt.

GET (Single)

Holen Sie sich Apfelartikel

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

#Antwort
{"name":"apple","price":"100"}

PUT Ändern Sie den Apfelpreis von 100-> 200

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

Tabelle nach PUT-Anfrage

DELETE Löschen Sie den Pfirsichartikel.

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

Tabelle nach DELETE-Anfrage

abschließend

Ich habe eine REST-API erstellt, die DynamoDB mit django REST Framework + boto3 betreibt. Dieses Mal habe ich dynamodb_model.py vorbereitet, um das Modell zu verwalten, aber es war möglicherweise nicht erforderlich (ich möchte das Design hier in Zukunft verbessern).