La première API à créer avec le framework Python Djnago REST

: débutant: créez une API de journal et publiez-la à partir de l'état initial

Le produit fini est ici. C'est l'API que je gère réellement mon agenda. : joie: lol http://www.kojimaiton-philosophy.com/api/diaries/

: crayon: Journal Comment utiliser REST_API

CRUD fournit la fonctionnalité minimale requise pour un agenda: fusée:

N'importe qui peut obtenir GET, mais POSTPUTDELETE n'est accessible à personne, alors ajoutez un jeton d'accès à l'en-tête. Remplacez XXXXXX_XXXXXX par le jeton d'accès acquis.

GET

Obtenez un journal dans la liste. La pagination, les filtres et les décalages de limite sont également disponibles.
$ curl http://localhost/api/diaries/

Obtenez un agenda avec la date comme clé primaire.
$ curl http://www.kojimaiton-philosophy.com/api/diaries/2016-12-19/

POST

Mettez le contenu nécessaire dans l'agenda et créez-en un nouveau * La date étant la clé principale, vous ne pouvez pas POSTER deux fois la même date.
$ curl -X POST http://www.kojimaiton-philosophy.com/api/diaries/ -d "date=2017-03-25" -d "title=Titre du journal" -d "body=Contenu du journal" -d "publishing=true" -H "Authorization: JWT XXXXXX_XXXXXX"`

PUT

Spécifiez la date que vous souhaitez mettre à jour dans le chemin, réécrivez-la avec les données que vous souhaitez modifier et mettez à jour.
$ curl -X PUT http://www.kojimaiton-philosophy.com/api/diaries/2017-03-25/ -d "date=2017-03-25" -d "title=Changer le titre du journal" -d "body=Changement de journal" -d "publishing=false" -H "Authorization: JWT XXXXXX_XXXXXX"

DELETE

Spécifiez la date à supprimer dans le chemin et supprimez les données.
$ curl -X DELETE http://www.kojimaiton-philosophy.com/api/diaries/2017-03-25/ -H "Authorization: JWT XXXXXX_XXXXXX"

: earth_asia: environnement

CentOS: 7.3.1 Python: 3.6.0 Django: 1.10.6 Restframework: 3.6.2 MySQL: 5.7.17 Nginx: 1.11.13

: châtaigne: paramètres

configuration de base

mettre à jour yum
$ sudo yum update -y
Installer git
$ sudo yum install git -y
Mettez les bibliothèques nécessaires
$ sudo yum install zlib-devel bzip2 bzip2-devel readline-devel openssl-devel sqlite3 sqlite-devel gcc -y

Paramètres liés au port

Désactivez firewalld pour vous entraîner
$ systemctl stop firewalld
firewalld démarrage / arrêt automatique
$ systemctl disable firewalld
Confirmation de SELinux
$ getenforce
En cas d'application, modifiez ci-dessous et SELINUX=Application SELINUX=Réécrire sur désactivé.
$ sudo vi /etc/selinux/config
En cas de réécriture, redémarrez la machine pour que les paramètres prennent effet
$ sudo shutdown -r now
Assurez-vous qu'il est désactivé
$ getenforce

Installez pyenv

$ git clone https://github.com/yyuu/pyenv.git ~/.pyenv
$ echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bash_profile
$ echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bash_profile
$ echo 'eval "$(pyenv init -)"' >> ~/.bash_profile
$ source ~/.bash_profile
$ exec $SHELL -l
Vérification
$ pyenv -v

installation de python

Vérifier la version
$ pyenv install -l
Cette fois 3.6.0 Installation * Cela prend beaucoup de temps pour terminer l'installation
$ pyenv install 3.6.0
Vérification
$ pyenv versions
Changer la valeur par défaut
$ pyenv global 3.6.0
Vérification
$ pyenv versions

Installer Django et les bibliothèques à utiliser

Installation de Django(python3.Pip est disponible par défaut à partir de 6)
$ pip install django
REST_Frame_Installation de travail
$ pip install djangorestframework
filtration
$ pip install django-filter
Jeton d'accès par JWT
$ pip install djangorestframework-jwt
Salt mysql avec Django
$ pip install PyMySQL
Exécutez Django sur le serveur de production
$ pip install uwsgi

: seedling: Création d'un projet Django

Créer un projet
$ django-admin startproject django_rest_framework
$ cd django_rest_framework
Correction du nom d'hôte. Entrez l'adresse IP / le domaine que vous utilisez.
$ sudo vi django_rest_framework/settings.py
ALLOWED_HOSTS = ['160.16.65.138', 'localhost', '127.0.0.1',]
manage.Démarrez le serveur dans le répertoire contenant le fichier py et vérifiez la connexion avec le navigateur. http://Nom de domaine:Il peut être confirmé à 8000. Ctrl pour arrêter le serveur+C
$ python manage.py runserver 0.0.0.0:8000
Paramètres pendant le fonctionnement du serveur.Le mode de débogage de py est défini sur true par défaut, donc si vous modifiez le fichier, il sera immédiatement reflété sur le serveur.

Vérifier la connexion depuis le navigateur

: white_sun_rain_cloud: paramètres de la base de données

Paramètres de la base de données côté CentOS

Il est facile d'utiliser SQLite, mais ici nous utiliserons MySQL, qui peut être utilisé fermement et universellement. (Bien que le réglage soit long: joie :)

La base de données créée en l'exécutant plus tôt.Supprimez sqlite3.
$ ls
db.sqlite3  diary  manage.py
$ rm db.sqlite3
MariaDB est incluse par défaut à partir de centos7, supprimez-la
$ sudo yum remove mariadb-libs -y
Si vous utilisiez une autre version de mysql, supprimez-la car ces données peuvent rester
$ rm -rf /var/lib/mysql/
Ajouter un référentiel MySQL
$ sudo yum -y install http://dev.mysql.com/get/mysql57-community-release-el6-7.noarch.rpm
Vérifiez le contenu installable
$ yum repolist enabled | grep "mysql.*-community.*"
Vérifiez les informations avec la commande info
$ yum info mysql-community-server
Installation
$ sudo yum -y install mysql-community-server
Confirmation de version
$ mysql --version
Démarrage automatique
$ sudo chkconfig mysqld on
Commencez
$ sudo systemctl start mysqld
Vérifiez le mot de passe par défaut
$ sudo vi /var/log/mysqld.log
Recherchez le mot de passe temporaire suivant dans le fichier journal. Cette fois, mon mot de passe est(E,Ressemble à irsThV0uB
2017-04-01T20:05:05.561190Z 1 [Note] A temporary password is generated for root@localhost: N4IYvEp&)6%!
Lorsque vous effectuez les opérations suivantes, un mot de passe vous sera demandé, alors entrez le chemin que vous avez trouvé ci-dessus
$ mysql -u root -p
Si vous ne modifiez pas le mot de passe temporaire, il n'acceptera aucun traitement, alors changez-le. Cependant, veuillez noter que ce mot de passe ne sera accepté que s'il contient au moins 8 caractères, lettres, chiffres et symboles.
$ ALTER USER root@localhost IDENTIFIED BY '@Mysql0001';
Une fois défini, quittez mysql une fois
$ exit;
Ajoutez une ligne au fichier suivant et définissez le japonais.[mysqld]Sous le personnage-set-server=Ajout de utf8.
$ sudo vi /etc/my.cnf
La description ressemble à ceci ↓
[mysqld]
character-set-server=utf8
Refléter les paramètres
$ sudo systemctl restart mysqld
Créer une base de données à utiliser avec Django
$ mysql -u root -p
Appelons ça diarydb ici.
$ create database diarydb;
Terminer après la création
$ exit

Paramètres de la base de données côté Django

Modifier settings.py $ vi django_rest_framework/settings.py

django_rest_framework/settings.py

import os
#Importer pymysql
import pymysql

#Changé pour utiliser mysql
pymysql.install_as_MySQLdb()
DATABASES = {
   'default': {
       'ENGINE': 'django.db.backends.mysql',
       #Nom de la base de données
       'NAME': 'diarydb',
       #Nom d'utilisateur
       'USER': 'root',
       #mot de passe
       'PASSWORD': '@Mysql0001',
       #L'adresse IP et l'hôte du serveur. Blank est l'hôte local
        'HOST': '',
       #Port
       'PORT': '3306',
       'OPTIONS': {
           #Vérifier strictement les contraintes
           'sql_mode': 'traditional',
       },
       #Utilisateur test
        'TEST_NAME': 'auto_tests',
   }
}

Vérifier si Django et MySQL peuvent se connecter

Créer un fichier de migration
$ python manage.py makemigrations
Reflect dans DB basé sur le fichier de migration
$ python manage.py migrate

Configuration de la base de données terminée ... Long: joie:

: herb: Modifier le projet Django

Créer une application de journal

$ cd django_rest_framework
$ python manage.py startapp diary

Cliquez ici pour la structure actuelle des répertoires. C'est comme ajouter des fichiers petit à petit ici: muscle:

└── django_rest_framework
    ├── diary
    │   ├── __init__.py
    │   ├── admin.py
    │   ├── apps.py
    │   ├── migrations
    │   │   └── __init__.py
    │   ├── models.py
    │   ├── tests.py
    │   └── views.py
    ├── django_rest_framework
    │   ├── __init__.py
    │   ├── __pycache__
    │   │   ├── __init__.cpython-36.pyc
    │   │   ├── settings.cpython-36.pyc
    │   │   ├── urls.cpython-36.pyc
    │   │   └── wsgi.cpython-36.pyc
    │   ├── settings.py
    │   ├── urls.py
    │   └── wsgi.py
    └── manage.py

Définir le modèle

Le modèle est en tête-à-tête avec le DB. Créer models.py $ vi diary/models.py

diary/models.py

# coding: utf-8
from django.db import models
from datetime import date

class Diary(models.Model):
    date = models.DateField(default=date.today, primary_key=True)
    title = models.CharField(max_length=128)
    body = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    publishing = models.BooleanField(default=True)

Définissez le modèle créé dans settings.py $ vi django_rest_framework/settings.py

django_rest_framework/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    #Ajouter un journal
    'diary',
]

Migrer à nouveau la base de données

$ python manage.py makemigrations
$ python manage.py migrate

Entrez dans l'écran de gestion de Django DB

Créer un utilisateur pour l'administrateur
$ python manage.py createsuperuser
Démarrez le serveur.
$ python manage.py runserver 0.0.0.0:8000

Accédez à l'écran d'administration http: // votre IP / domaine: 8000 / admin /

Entrez le ʻUsername et le Passwordcréés danscreateuperuser` plus tôt pour entrer dans l'écran de gestion. Vous pouvez cliquer sur l'interface graphique pour modifier ou ajouter des modèles.

Ajoutez ici le modèle créé précédemment afin qu'il puisse être utilisé à partir de l'interface graphique. $ vi diary/admin.py

diary/admin.py

# coding: utf-8
from django.contrib import admin
from .models import Diary


@admin.register(Diary)
class Diary(admin.ModelAdmin):
    pass

DIARY a été ajouté à l'écran d'administration: muscle: Faisons ici un journal à utiliser dans l'API. Diarys -> Add diary -> SAVE

: ear_of_rice: Présentation du framework REST

Définir le cadre REST

$ vi django_rest_framework/settings.py

django_rest_framework/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    #Ajouter un journal
    'diary',
    #Ajouter un cadre
    'rest_framework',
]

Définir le sérialiseur

Limiter les champs à générer vers l'API dans la classe Serializer $ vi diary/serializer.py

diary/serializer.py

# coding: utf-8
from rest_framework import serializers
from .models import Diary


class DiarySerializer(serializers.ModelSerializer):
    class Meta:
        model = Diary
        fields = ('date', 'title', 'body', 'publishing',)

Définir ViewSet

ViewSet est un contrôleur $ vi diary/views.py

diary/views.py

# coding: utf-8
from rest_framework import viewsets
from .models import Diary
from .serializer import DiarySerializer


class DiaryViewSet(viewsets.ModelViewSet):
    queryset = Diary.objects.all()
    serializer_class = DiarySerializer

Définir des URL

Les URL sont un paramètre de routeur d'URL

Enregistrez le DiaryViewSet créé $ vi diary/urls.py

diary/urls.py

# coding: utf-8
from rest_framework import routers
from .views import DiaryViewSet

router = routers.DefaultRouter()
router.register(r'diaries', DiaryViewSet)

Paramétrage du routage accessible de l'extérieur $ vi django_rest_framework/urls.py

django_rest_framework/urls.py

# coding: utf-8
from django.conf.urls import url, include
from django.contrib import admin
from diary.urls import router as diary_router

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^api/', include(diary_router.urls)),
]

Exécuter et vérifier

Lancez le serveur $ python manage.py runserver 0.0.0.0:8000 Connectez-vous avec le navigateur http: // Mon IP / Domaine: 8000 / api / diaries /

Quand je le frappe avec curl, json est renvoyé.

$ curl http://160.16.65.138:8000/api/diaries/
[{"date":"2017-04-15","title":"Test de titre","body":"Test de contenu","publishing":true},{"date":"2017-04-16","title":"Titre","body":"Contenu!","publishing":true}]

Il convient de noter ici que les caractères sont déformés lorsqu'ils sont visualisés avec json depuis le menu déroulant avec le bouton à côté de GET dans l'image ci-dessus. : crier: Il peut ne pas être déformé selon la version de Chrome, mais il est automatiquement converti en ʻUTF-8. Si vous le regardez sans spécifier ʻUTF-8 dans Safari etc., il semble que les caractères sont brouillés. Pour corriger ce qui suit, vous devez spécifier ʻUTF-8 ici pour le json` renvoyé au client.

Spécifiez json comme utf-8

La documentation REST Framework indique UTF-8 par défaut: joy: $ vi diary/renderers.py Création d'une classe ʻUTF8CharsetJSONRenderer avec ʻUTF-8 Le paramètre par défaut rest_framework.renderers.JSONRenderer semble être ʻUTF-8`, mais je ne pouvais pas. .. ..

diary/renderers.py

from rest_framework.renderers import JSONRenderer


class UTF8CharsetJSONRenderer(JSONRenderer):
    charset = 'utf-8'

Ajoutez ce qui suit à settings.py $ vi django_rest_framework/settings.py

django_rest_framework/settings.py

REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': (
        'diary.renderers.UTF8CharsetJSONRenderer',
    )
}

Caractères déformés corrigés: muscle:

: palm_tree: Vérifier CURD

Changez l'emplacement IP pour le vôtre et demandez: point_up:

POST(Create)

Créer un nouveau
$ curl -X POST http://160.16.65.138:8000/api/diaries/ -d "date=2017-04-22" -d "title=Titre du journal" -d "body=Test POST" -d "publishing=true"

PUT(Update)

mise à jour
$ curl -X PUT http://160.16.65.138:8000/api/diaries/2017-04-22/ -d "date=2017-04-22" -d "title=Changer le titre du journal" -d "body=Test PUT" -d "publishing=false"

GET(Read)

Obtenir la liste
$ curl http://160.16.65.138:8000/api/diaries/
Obtenir par date
$ curl http://160.16.65.138:8000/api/diaries/2017-04-22/

DELETE(Delete)

Effacer
$ curl -X DELETE http://160.16.65.138:8000/api/diaries/2017-04-22/

: date: Pagénation

Ajouter une pagination $ vi django_rest_framework/settings.py

django_rest_framework/settings.py

REST_FRAMEWORK = {
    #ajouter à
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE': 3,
    'DEFAULT_RENDERER_CLASSES': (
        'diary.renderers.UTF8CharsetJSONRenderer',
    )
}

Lorsque vous l'obtenez, next et previous sont ajoutés à la racine de json, et vous pouvez suivre les pages précédentes et suivantes. $ curl http://160.16.65.138:8000/api/diaries/

{
    count: 4,
    next: "http://160.16.65.138:8000/api/diaries/?limit=3&offset=3",
    previous: null,
    results: [
        {
            date: "2017-04-15",
            title: "Test de titre",
            body: "Test de contenu",
            publishing: true
        },
        {
            date: "2017-04-16",
            title: "Titre",
            body: "Contenu!",
            publishing: true
        },
        {
            date: "2017-04-21",
            title: "hoge",
            body: "ssss",
            publishing: true
        }
    ]
}

: spider_web: filtre

Modifier views.py $ vi diary/views.py

diary/views.py

# coding: utf-8
from rest_framework import viewsets
from .models import Diary
from .serializer import DiarySerializer


class DiaryViewSet(viewsets.ModelViewSet):
    queryset = Diary.objects.all()
    serializer_class = DiarySerializer
    #Ajouter un filtre
    filter_fields = ('publishing',)

Modifier settings.py $ vi django_rest_framework/settings.py

django_rest_framework/settings.py

REST_FRAMEWORK = {
    #Ajouter un filtre
    'DEFAULT_FILTER_BACKENDS': ('rest_framework.filters.DjangoFilterBackend',),
    #Ajouter une nation de page
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE': 3,
    'DEFAULT_RENDERER_CLASSES': (
        'diary.renderers.UTF8CharsetJSONRenderer',
    )
}

Essayez de filtrer l'indicateur public uniquement sur faux Ajouter`?

$ curl http://160.16.65.138:8000/api/diaries/?publing=false

{
    count: 1,
    next: null,
    previous: null,
    results: [
        {
            date: "2017-04-22",
            title: "hogehoge",
            body: "hoge",
            publishing: false
        }
    ]
}

: boy_tone1: Authentification

Il existe différentes méthodes d'authentification, mais cette fois j'ai utilisé JWT (Json Web Token)

Modifier settings.py $ vi django_rest_framework/settings.py

django_rest_framework/settings.py

REST_FRAMEWORK = {
    #Ajout de la certification JWT
    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAuthenticated',
    ),
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_jwt.authentication.JSONWebTokenAuthentication',
    ),
    'NON_FIELD_ERRORS_KEY': 'detail',
    'TEST_REQUEST_DEFAULT_FORMAT': 'json',
    #Ajouter un filtre
    'DEFAULT_FILTER_BACKENDS': ('rest_framework.filters.DjangoFilterBackend',),
    #Ajouter une nation de page
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE': 3,
    'DEFAULT_RENDERER_CLASSES': (
        'diary.renderers.UTF8CharsetJSONRenderer',
    )
}

#Ajout de la certification JWT
JWT_AUTH = {
    #Essayez d'invalider l'expiration du jeton ici
    'JWT_VERIFY_EXPIRATION': False,
}

Modifier ʻurls.py $ vi django_rest_framework/urls.py`

django_rest_framework/urls.py

# coding: utf-8
from django.conf.urls import url, include
from django.contrib import admin
from diary.urls import router as diary_router
#Ajouter une authentification
from rest_framework_jwt.views import obtain_jwt_token

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^api/', include(diary_router.urls)),
    #Ajouter une authentification
    url(r'^api-auth/', obtain_jwt_token),
]

Obtention du jeton d'accès JWT

Demande avec l'utilisateur ʻadmin ʻusername et password créés par createsuperuser

$ curl http://160.16.65.138:8000/api-auth/ -d "username=XXXXXXX&password=XXXXXXXX"

En cas de succès, «token» sera inclus dans la réponse.

{"token":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoyLCJlbWFpbCI6Im11dS5rb2ppbWEudGVzdEBnbWFpbC5jb20iLCJ1c2VybmFtZSI6ImRqYW5nbyIsImV4cCI6MTQ5Mjg1NTMxMH0.m07BcTiAkA79HZ0BC8BsgYOA-SbqmC5GMN5g_QBizZw"}

Si le nom d'utilisateur et le mot de passe sont différents, il échouera comme suit

{"detail":["Unable to login with provided credentials."]}

Modifiez views.py et authentifiez-vous $ vi diary/views.py

diary/views.py

# coding: utf-8
from rest_framework import viewsets
from .models import Diary
from .serializer import DiarySerializer
#Ajouter une authentification
from rest_framework import permissions


class DiaryViewSet(viewsets.ModelViewSet):
    queryset = Diary.objects.all()
    serializer_class = DiarySerializer
    #Ajouter un filtre
    filter_fields = ('publishing',)
    #Ajout de l'authentification Si vous souhaitez authentifier tous les CURD(permissions.IsAuthenticated,)À
    permission_classes = (permissions.IsAuthenticatedOrReadOnly,)

Essayez d'être authentifié

Créer un nouveau

$ curl -X POST http://160.16.65.138:8000/api/diaries/ -d" date = 21/04/2017 "-d" title = authentification "-d" body = test d'authentification "-d" publication = vrai " `

Puisqu'il n'y a pas de jeton d'accès, c'est OK s'il échoue comme suit!

{"detail":"Authentication credentials were not provided."}

POST avec le jeton d'accès acquis * Remplacez le jeton d'accès par le vôtre

$ curl -X POST http://160.16.65.138:8000/api/diaries/ -d "date=2017-04-10" -d "title=Authentification" -d "body=Authentificationのテスト" -d "publishing=true" -H "Authorization: JWT eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoyLCJlbWFpbCI6Im11dS5rb2ppbWEudGVzdEBnbWFpbC5jb20iLCJ1c2VybmFtZSI6ImRqYW5nbyIsImV4cCI6MTQ5Mjg1NTMxMH0.m07BcTiAkA79HZ0BC8BsgYOA-SbqmC5GMN5g_QBizZw"

Une fois créé, assurez-vous que tout sauf GET est authentifié: fist:

• Référence à permissions.IsAuthenticatedOrReadOnly, donc si vous prenez ʻOrReadOnly, GET` sera également authentifié.

Correction de la page 404 à la normale.

Lors de l'accès à l'itinéraire actuel, Django utilise par défaut: http://160.16.65.138:8000/

Modifiez settings.py et définissez DEBUG = False selon le libellé en bas. * Si vous définissez DEBUG = False, les changements de fichier ne peuvent pas être reflétés automatiquement lors du démarrage du serveur. Donc sois prudent You're seeing this error because you have DEBUG = True in your Django settings file. Change that to False, and Django will display a standard 404 page.

$ vi django_rest_framework/settings.py

django_rest_framework/settings.py

...réduction

# DEBUG =S'il est défini sur False, ce sera une page 404 normale.
DEBUG = False

...réduction

Quand j'y ai accédé, c'est devenu une page 404 normale!

: robot: cas de test

tests.Supprimer py
$ rm diary/tests.py
Créez un répertoire de test. Mettez le test ici
$ mkdir diary/tests
Pour être reconnu comme un répertoire python`__init__.py`Ajouter. Rien de particulier n'est décrit.
$ vi diary/tests/__init__.py

Créez test_diary.py pour l'authentification et les tests CRUD

$ vi diary/tests/test_diary.py

diary/tests/test_diary.py

# coding: utf-8
from rest_framework import status
from rest_framework.test import APITestCase
from rest_framework_jwt.compat import get_user_model
from rest_framework_jwt.settings import api_settings


class DiaryTest(APITestCase):
    def setUp(self):
        #Émission du jeton d'accès
        User = get_user_model()
        self.username = 'test_user'
        self.email = '[email protected]'
        self.user = User.objects.create_user(self.username, self.email)
        jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
        jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
        payload = jwt_payload_handler(self.user)
        token = jwt_encode_handler(payload)
        self.auth = 'JWT {0}'.format(token)
        self.url = '/api/diaries/'

    def test_diary_api(self):
        # POST
        data = {
            "date": "2011-11-11",
            "title": "title",
            "body": "body",
            "publishing": True,
        }
        response = self.client.post(self.url, data, HTTP_AUTHORIZATION=self.auth)
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(response.data, data)

        # GET
        expected_get_data = {
            "count": 1,
            "next": None,
            "previous": None,
            "results": [
                {
                    "date": "2011-11-11",
                    "title": "title",
                    "body": "body",
                    "publishing": True,
                }
            ]
        }
        response = self.client.get(self.url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data, expected_get_data)

        # PUT
        data2 = {
            "date": "2010-10-10",
            "title": "title",
            "body": "body",
            "publishing": False,
        }
        response = self.client.put(self.url + '2011-11-11/', data2, HTTP_AUTHORIZATION=self.auth)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data, data2)

        # DELETE
        response = self.client.delete(self.url + '2010-10-10/', HTTP_AUTHORIZATION=self.auth)
        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)

Lancer le test

Ce qui suit exécutera test_xxxx.py dans tests. $ ./manage.py test

Le test a réussi!

[xxxxx@tk2-208-13884 django_rest_framework]$ ./manage.py test
Creating test database for alias 'default'...
System check identified no issues (0 silenced).
.
----------------------------------------------------------------------
Ran 1 test in 0.049s

OK
Destroying test database for alias 'default'...

: mailbox_with_mail: paramètres de proxy inverse (supprimer: 8000 sur le point de terminaison de l'API)

installation de nginx

Créez un fichier de nginx.repo pour ajouter un référentiel $ sudo vi /etc/yum.repos.d/nginx.repo

nginx.repo

[nginx]
name=nginx repo
baseurl=http://nginx.org/packages/mainline/centos/7/$basearch/
gpgcheck=0
enabled=1

Installer et lancer

Installer nginx
$ sudo yum install nginx -y
Vérifier la version
$ nginx -v
Réglage de démarrage automatique
$ sudo systemctl enable nginx
Commencez
$ sudo systemctl start nginx

Vérifiez la page par défaut

Vérifiez l'affichage. http: // IP de mon serveur / Voici mon exemple. http://160.16.65.138/

• Le chemin par défaut de ʻindex.htmlci-dessus est/ usr / share / nginx / html / index.html`

Configurer un proxy inverse

Créez un fichier sous /etc/nginx/conf.d avec le nom XXX.conf Ici, il est appelé server.conf, et la requête reçue au numéro 80 est transmise au numéro 8000. $ sudo vi /etc/nginx/conf.d/server.conf

server.conf

server {
     listen 80;
     #Une adresse IP ou un domaine accessible. Ci-dessous mon exemple
     server_name 160.16.65.138;
     proxy_set_header X-Real-IP $remote_addr;
     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
     proxy_set_header Host $http_host;
     proxy_redirect off;
     proxy_max_temp_file_size 0;
     location / {
        #Destination de transfert
        proxy_pass http://localhost:8000;
     }:joy:
}

redémarrez nginx pour refléter les paramètres

$ sudo systemctl restart nginx

Une fois exécuté, il sera accessible depuis le navigateur avec le HTTP par défaut «80», donc «8000» n'est pas nécessaire. python manage.py runserver 0.0.0.0:8000

: camping: Démarrez Django avec un démon et exécutez-le en production

Essayez de le faire fonctionner en arrière-plan même si vous quittez le serveur.

Définissez un mot de passe pour la racine
$ sudo passwd root
Devenez la racine
$ su
Exécutez Django sur un démon de production
$ uwsgi --http :8000 --module django_rest_framework.wsgi --daemonize /var/log/uwsgi-django.log

Maintenant, il devrait fonctionner en arrière-plan! Pour arrêter ʻuwsgide fonctionner en arrière-plan,tuez le PID` du serveur en cours d'exécution.

Trouver $ netstat -ntlp

Il est affiché à côté de ʻuwsgi, mais comme il s'agit de PID, Dans ce cas, kill -9 32215` arrêtera le serveur.

Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN      32181/nginx: master
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      861/sshd
tcp        0      0 0.0.0.0:8000            0.0.0.0:*               LISTEN      32215/uwsgi
tcp        0      0 127.0.0.1:43047         0.0.0.0:*               LISTEN      32215/uwsgi
tcp6       0      0 :::22                   :::*                    LISTEN      861/sshd
tcp6       0      0 :::3306                 :::*                    LISTEN      19382/mysqld

Comment lire «uwsgi» semble être du whisky? J'ai lu "Uesugi": joie:

: cat: Résumé

Mettez le produit fini sur Github: ampoule:

https://github.com/MuuKojima/django_rest_framework

C'est l'API que je gère réellement mon agenda. : joie: lol

http://www.kojimaiton-philosophy.com/api/diaries/ Tout en nous développant, nous continuerons à opérer toute une vie: muscle: Ceci est opéré sur AWS!

référence

http://qiita.com/redamoon/items/eabaacabb5b1a0c34ca3 http://qiita.com/seizans/items/05a909960820dd92a80a http://racchai.hatenablog.com/entry/2016/05/08/070000 http://var.blog.jp/archives/70125676.html