Comment créer une application à partir du cloud à l'aide du framework Web Django

Cet article vous montrera comment créer une application à partir du cloud à l'aide du ** Django Web Framework ** pour aider les développeurs Web à relever les défis auxquels ils sont confrontés aujourd'hui.

Pourquoi Django?

Avant de parler de Django, laissez-moi vous dire ce qu'est une application Web. Une application Web est un ensemble de code écrit dans un langage de programmation qui est rendu sur un navigateur et résout généralement des problèmes bien définis. Par exemple, un article de blog (comme celui-ci!), Un site Web de commerce électronique ou un réseau social.

Eh bien, c'est assez simple, mais qu'est-ce qu'un framework Web? Un framework Web est un ensemble de composants réutilisables qui gèrent de manière intégrée de nombreuses tâches courantes et répétitives du développement d'applications Web. Au lieu d'avoir à obtenir une bibliothèque de codes différents et à trouver un moyen de les faire fonctionner ensemble, le framework Web fournit tous les composants dont vous avez besoin dans un seul package et s'occupe de l'intégration. ..

Maintenant que vous connaissez le concept d'applications et de frameworks Web, parlons de Django. Django est l'un des derniers frameworks Web visant à simplifier la création d'applications Web. Django fournit un ensemble d'outils pour vous aider à développer rapidement des applications Web réutilisables, évolutives, propres et hautement dynamiques.

Django est construit sur le paradigme DRY (Don't Repeat Yourself), et vous devez écrire moins de code que le code moyen requis en utilisant d'autres frameworks à chaque étape du processus de développement. Cela signifie ne pas être.

Cette série de tutoriels vous guidera à travers le développement de plusieurs applications, comment les différents composants et applications fournis avec Django vous aideront à écrire moins de code à chaque étape du processus de développement. Voici comment faire tout cela dans le cloud. Cette fois, nous exécuterons l'application Web sur une instance Alibaba Cloud Elastic Compute Service (ECS). La procédure de configuration de Django sur ECS n'est pas décrite. Au lieu de cela, reportez-vous aux deux didacticiels suivants.

1、https://www.alibabacloud.com/getting-started/projects/how-to-deploy-django-application-on-alibaba-cloud 2、http://www.alibabacloud.com/blog/how-to-deploy-a-django-application-with-docker_581157

Définition de projet

Le projet que nous essayons de construire est une application Web de commerce électronique qui permet aux gens d'acheter et de vendre des biens. Pour plus de flexibilité et de maintenabilité, le projet est divisé en trois applications indépendantes: l'application principale, l'application panier et l'application de paiement.

Présentation de chaque application

Application principale

Comme mentionné précédemment, l'application principale gère tout ce qui concerne le produit que vous souhaitez vendre (ajouts, modifications, suppressions). L'application principale vise à gérer l'ensemble du processus d'achat.

1, utilisateur (acheteur / vendeur et administrateur) 2, informations sur le produit 3, catégorie de produit

Application de chariot

L'application de panier est utilisée pour gérer le processus d'achat et de vente. Les éléments spécifiques gérés ici sont les suivants.

1, options d'achat et de vente 2, le panier du client et les articles du panier 3, ajouter / supprimer des articles au panier

Application de paiement

L'application de paiement vous donne accès à la passerelle de paiement et vous permet de recevoir l'argent transmis par le client. Cliquez ici pour plus de détails:

1, passerelle de paiement 2, méthode de paiement 3, intégration de l'API de paiement

Paramètres de l'environnement de développement

Installez python 3 et pip

$ python --version
# sudo apt-get install python3
# sudo apt-get install python-pip

Installation de la base de données PostgreSQL

# sudo apt-get update
# sudo apt-get install python-dev libpq-dev postgresql postgresql-contrib

Installation de virtualenv

# sudo pip install virtualenv

Installation d'oreillers En utilisant cette bibliothèque, vous pourrez imprimer des profils et des images de produits sur des modèles.

(venv)$ pip install pillow

Lancement et configuration du projet

Créer et activer un environnement virtuel

Cette commande crée un environnement virtuel dans le dossier venv qui fait de python3 l'interpréteur python par défaut.

$ virtualenv venv --python=python3               
$ cd venv

Cette commande active cet environnement virtuel.

$ source bin/activate      

Installer Django dans un environnement virtuel

(venv)$ cd venv
(venv)$ pip install django==2.1      

Créer un projet Django

(venv)$ django-admin startproject buyandsell

Après avoir terminé avec succès chacune des étapes ci-dessus, le dossier de projet résultant devrait ressembler à ceci:

buyandsell/
    buyandsell/
        __init__.py
        settings.py
        urls.py
        wsgi.py
    db.sqlite3
    manage.py

Voici quelques-uns des fichiers affichés dans ce dossier.

1, ** settings.py **: ce fichier est utilisé pour définir la configuration principale de l'application, comme les paramètres d'accès à la base de données et les définitions de service de fichiers statiques. 2, ** urls.py **: Ce fichier est utilisé pour créer une racine URL qui fournit le contenu stocké par l'application. 3, ** wsgi.py **: ce fichier définit les paramètres par défaut utilisés par le serveur Web dans les paramètres de déploiement. 4, ** manage.py **: Le script principal de gestion du projet Django et de ses applications (migration de base de données, exécution de test, exécution de serveur de développement). 5, ** db.sqlite3 **: Il s'agit du préréglage de base de données par défaut dans Django. Utilisez-le pour le développement uniquement, mais lors du déploiement, changez-le en une base de données PostgreSQL qui sera utilisée en conjonction avec l'application Django. 6, ** admin.py **: Utilisé pour générer une application d'interface d'administration. 7, ** tests.py **: définit les tests à exécuter lors du test de l'application. 8, ** app.py **: ce fichier contient les paramètres par défaut de l'application.

Effectuer une migration initiale pour initialiser la base de données

Après avoir créé le projet, vous devez créer des tables de base telles que User, Session, etc. pour fournir le comportement par défaut de Django.

(venv)$ cd buyandsell
(venv)$ python manage.py migrate

Créer un super utilisateur

Le superutilisateur Django est l'utilisateur root de Linux, et cet utilisateur a tous les droits sur les données stockées dans la base de données Django. Cet utilisateur a tous accès à l'interface d'administration.

(venv)$ cd buyandsell
(venv)$ python manage.py createsuperuser admin

Remarque: veuillez saisir un mot de passe à 8 caractères qui est un mélange de chiffres majuscules et minuscules et de caractères spéciaux.

Tester si l'application fonctionne correctement

Vous pouvez le tester en exécutant une commande dans le dossier racine «acheter et vendre».

(venv)$ python manage.py runserver SERVER_IP:SERVER_PORT

SERVER_IP est l'adresse IP publique de l'instance de machine virtuelle et SERVER_PORT est le port externe configuré sur le serveur.

Développement d'applications de base

Toutes les applications développées dans ce didacticiel suivent le processus ci-dessous.

  1. Définissez le modèle de base de données dans le fichier models.py.
  2. Définissez les vues qui gèrent la demande dans le fichier views.py et créez un fichier HTML modèle qui sera utilisé pour rendre le fichier pour l'utilisateur final.
  3. Utilisez le fichier urls.py pour définir un itinéraire permettant aux utilisateurs de naviguer dans l'application.
  4. Utilisez le fichier admin.py pour définir les paramètres de l'interface administrateur qui aident les administrateurs d'application à gérer sans effort les entités stockées dans la base de données. 5, puis personnalisez le modèle pour le rendre plus mignon.

Initialisation de l'application principale

(venv)$ cd buyandsell
(venv)$ django-admin startapp core

Après l'initialisation de l'application principale, le dossier du projet doit avoir un nouveau dossier avec la structure suivante:

core/
        __init__.py
        admin.py
        apps.py
        migrations/
            __init__.py
        models.py
        tests.py
        views.py

Lier les applications principales aux projets d'achat et de vente

Pour que Django considère l'application principale dans le cadre du projet d'achat et de vente, vous devez ajouter les paramètres suivants à votre fichier settings.py:

….
INSTALLED_APPS = [
   'core',
    …
]
….

Modèle de données

Comme mentionné ci-dessus, cette application gère les modèles suivants.

1, profil utilisateur 2, produit 3, catégorie de produit Et voici le code source correspondant.

from django.db import models
from django.urls import reverse
from django.contrib.auth.models import User
from django.conf import settings
from datetime import datetime

class UserProfile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
photo = models.ImageField(upload_to='profile_images', blank=True)
phone = models.CharField(max_length=20)

def __str__(self):
return self.user + "profile"

def get_absolute_url(self):
return reverse("profile_detail", kwargs={"pk": self.pk})

class Product(models.Model):
""" This the default Product class """
name = models.CharField(max_length=50)
description = models.TextField(max_length=100)
photo = models.ImageField(upload_to='product_images', blank=True)
price_ht = models.FloatField()
category = models.ForeignKey("core.Category", on_delete=models.CASCADE)
created_at = models.DateTimeField(default=datetime.now)
created_by = models.ForeignKey(User, on_delete=models.CASCADE)
TVA_AMOUNT = 19.25

def price_ttc(self):
return self.price_ht + self.TVA_AMOUNT

def __str__(self):
return self.name        

def get_absolute_url(self):
return reverse("product_detail", kwargs={"pk": self.pk})

class Category(models.Model):
name = models.CharField(max_length=50)
description = models.TextField(max_length=100)
photo = models.ImageField(upload_to='category_images', blank=True)

def __str__(self):
return self.name

def get_absolute_url(self):
return reverse("category_detail", kwargs={"pk": self.pk})

Après avoir défini le modèle, vous devez enregistrer ces structures dans la base de données à l'aide de la commande suivante:

(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate

Vues et fichiers modèles

Vous devez définir des vues et des fichiers modèles afin que les utilisateurs finaux puissent accéder à votre application à partir de votre navigateur.

Créez des vues et des fichiers de modèle pour gérer la création, les mises à jour, les suppressions, les listes et les détails du modèle.

Le contenu du fichier views.py est indiqué ci-dessous.

from django.shortcuts import render
from django.views.generic import DetailView, ListView, CreateView, UpdateView, DeleteView

from .models import Product, Category, UserProfile

# Product views
class ProductDetailView(DetailView):
model = Product
template_name = "core/product_detail.html"

class ProductListView(ListView):
model = Product
template_name = "core/product_list.html"

class ProductCreateView(CreateView):
model = Product
template_name = "core/product_create.html"

def form_valid(self, form):
form.instance.created_by = self.request.user
return super().form_valid(form)

class ProductUpdateView(UpdateView):
model = Product
template_name = "core/product_update.html"

class ProductDeleteView(DeleteView):
model = Product
template_name = "core/product_delete.html"

Ici, nous allons présenter le modèle Html utilisé pour afficher le formulaire de création de produit.

{% extends 'base.html' %}

{% block title %} Creation of a product {% endblock %}

{% block menu_bar %}
{{ block.super }}
<li class="active" ><a href="{% url 'product-list' %}">products</a></li>
{% endblock menu_bar %}

{% block content %}
<h3>Creation of a product</h3>
<form action="" method="post" enctype="multipart/form-data" >
{% csrf_token %}
{{ form.as_p }}
<input type="submit" value="Create">
<button class="button"><a href="{% url 'product-list' %}">Cancel</a></button>
</form>
{% endblock %}

Le fichier de modèle Html se trouve dans le répertoire templates / core dans le dossier racine de l'application principale.

Pour plus d'informations sur l'utilisation des fichiers de modèle Django, voir: django-website / templates

Routage par URLConf

UrlConf est une structure qui définit la manière dont la navigation est effectuée sur votre application. Il est défini dans le fichier views.py.

Vous trouverez ci-dessous le contenu de ce fichier.

# Product Urls
urlpatterns = [
path('products/', views.ProductListView.as_view(), name='product-list'),
path('product/<int:pk>/', views.ProductDetailView.as_view(), name='product-detail'),
path('product/create/', views.ProductCreateView.as_view(), name='product-create'),
path('product/<int:pk>/update/', views.ProductUpdateView.as_view(), name='product-update'),
path('product/<int:pk>/delete/', views.ProductDeleteView.as_view(), name='product-delete'),
]

Les itinéraires définis jusqu'à présent servent de points d'entrée pour accéder aux fichiers modèles définis dans la section vue. Ce fichier crée une liaison entre le chemin de l'URL et la vue associée à cette URL.

Interface administrateur

En général, lorsque vous créez une application Web pour répondre aux besoins professionnels de votre client, vous créez également une application d'administrateur qui gère les données, les autorisations, les autorisations et les rôles stockés dans la base de données. Django simplifie la vie des développeurs web car cela se fait déjà par défaut.

Pour configurer l'interface d'administration, vous devez modifier admin.py et le configurer pour utiliser le modèle.

Les réglages sont effectués de cette manière.

  1. Importez le modèle que vous souhaitez ajouter à l'application d'administration dans le fichier admin.py.
from core.models import Product
  1. Créez une classe ModelAdmin qui gère votre modèle.
class ProductAdmin(admin.ModelAdmin):
pass
  1. Enregistrez la classe ModelAdmin de l'interface d'administration à l'aide de l'une des deux méthodes suivantes: Utilisez la méthode d'enregistrement de admin.site
admin.site.register(Product, ProductAdmin)

Vous pouvez également annoter la classe ProductAdmin.

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
pass

Après avoir répété ces étapes pour tous les modèles, utilisez le code suivant dans le fichier admin.py.

from django.contrib import admin
from core.models import Product, Category, UserProfile

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
pass

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
pass

@admin.register(UserProfile)
class UserProfileAdmin(admin.ModelAdmin):
pass

Une fois que cela est fait, vous pouvez ouvrir votre navigateur à l'adresse suivante pour voir l'écran d'administration.

127.0.0.1:8000/admin/

Vous vous êtes connecté avec le compte de super utilisateur créé dans ce didacticiel.

Style d'application avec des fichiers statiques

Maintenant que nous avons une application fonctionnelle, nous essayons d'ajouter des styles pour la rendre plus visible. Utilisez donc Bootstrap 3 et la bibliothèque Jquery pour ajouter des styles à votre application.

Il existe un processus pour le faire.

Téléchargez le fichier source correspondant.

1、bootstrap.css 2、bootstrap.js 3、jquery.js

Créez un sous-dossier appelé static dans le dossier principal et créez un autre dossier nommé core à l'intérieur. De cette façon, placez les fichiers statiques de l'application principale dans ces dossiers.

  1. Créez un dossier css pour stocker le fichier css
  2. Créez un dossier js pour enregistrer le fichier javascript 3, créez un dossier d'images pour enregistrer des images

Définissez les paramètres STATIC_ROOT et STATIC_URL pour accéder à ces fichiers depuis votre navigateur

STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, '/static/')

Consolidez les fichiers statiques dans le fichier base.html et mettez les modèles hérités à la disposition de ces bibliothèques.

Tout d'abord, chargez toutes les bibliothèques statiques.

{% load static %}

Vous pouvez désormais utiliser cette balise pour utiliser des ressources statiques dans des dossiers statiques, comme illustré ci-dessous.

{% static 'core/css/bootstrap.css' %}

Vous trouverez ci-dessous le fichier base.html qui résulte de l'importation réussie de toutes les ressources statiques.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="description" content="">
<meta name="author" content="">
<link rel="icon" href="../../favicon.ico">
<title>{% block title %} Welcome to the core app !! {% endblock %}</title>

<link rel="stylesheet" type="text/css" href="{% static 'core/css/bootstrap.css' %}">
<link rel="stylesheet" type="text/css" href="{% static 'core/css/main.css' %}">

</head>

<body>
<script src="{% static 'core/js/jquery.js' %}"></script>
<script src="{% static 'core/js/bootstrap.js' %}"></script>
</body>
</html>

Conclusion

À la fin de ce didacticiel, vous verrez comment créer une application à l'aide du framework Web Django. Plus précisément, nous avons appris quels sont les modèles, vues et modèles de Django.

Le code source de l'application utilisée dans ce didacticiel se trouve sur GitHub.

https://github.com/binel01/buyandsell/tree/master/core

Recommended Posts

Comment créer une application à partir du cloud à l'aide du framework Web Django
Essayez d'utiliser le framework web de Python Django (1) - De l'installation au démarrage du serveur
Essayez d'utiliser le framework d'application Web Flask
Comment créer un article à partir de la ligne de commande
(Python) Essayez de développer une application Web en utilisant Django
Comment déployer une application Django dans le cloud Alibaba
[Mémo d'apprentissage] Comment créer une application avec Django ~ De l'environnement virtuel au push vers github ~
Comment écrire une validation personnalisée dans Django REST Framework
Essayez d'utiliser le framework Web Python Django (2) - Regardez setting.py
Comment réinitialiser le mot de passe via l'API à l'aide du framework Rest Django
Comment générer une requête à l'aide de l'opérateur IN dans Django
Comment effectuer les réglages initiaux à partir de la création de projet Django
Comment accéder à NAPALM depuis le Web (solution réelle NetDevOpsSec)
Développement d'une application WEB avec Django [Ajout d'application]
Créer une application Web avec Django
Développement d'une application WEB avec Django [Ajouter des données depuis l'écran de gestion]
Comment obtenir des abonnés et des abonnés de Python à l'aide de l'API Mastodon
Comment déployer une application Web sur Alibaba Cloud en tant que pigiste
Développement d'une application WEB avec Django [Définition de modèle]
Comment vérifier la version de Django
Développement d'une application WEB avec Django [Traitement des requêtes]
Développement d'une application WEB avec Django [modèle supplémentaire]
Comment faire fonctionner Linux depuis la console
Créer une application à l'aide de l'API Spotify
Comment accéder à la banque de données de l'extérieur
Je souhaite utiliser DB en utilisant l'ORM de Django à partir d'une application externe
[Django] Comment passer des valeurs directement des balises de modèle aux variables JavaScript
Comment réparer la merde lors de la lecture d'images Google Cloud Storage de Django déployées sur GAE
Essayez d'écrire du code à partir de 1 en utilisant le chainer du cadre d'apprentissage automatique (édition mnist)
Créons une application Web de conversion A vers B avec Flask! De zéro ...
Comment ouvrir un navigateur Web à partir de python
Comment créer un environnement pour utiliser plusieurs versions de Python sur un Mac
Développement d'une application WEB avec Django [Création de l'écran d'administration]
Un exemple de cloudbuild.yaml lors du déploiement automatique de Django sur App Engine avec Cloud Build
Comment appeler l'API Cloud à partir de GCP Cloud Functions
Essayez d'utiliser le framework Web Python Tornado Partie 1
Comment générer automatiquement un document API avec le framework Django REST et POST à partir de l'écran de document
Comment imprimer des messages de débogage sur la console Django
Comment utiliser l'API Google Cloud Translation
Comment faire fonctionner Linux depuis l'extérieur Procédure
Comment mesurer la vitesse de la ligne depuis le terminal
Essayez d'utiliser le framework Web Python Tornado Partie 2
Les débutants essaient de créer une application Web de combat en ligne Othello avec Django + React + Bootstrap (1)
[Mémo d'apprentissage] Comment créer une application avec Django ~ Jusqu'à ce que Hello World soit affiché ~
[Cloud 9] Essayez de créer un environnement avec django 1.11 de Python 3.4 sans même comprendre 1 mm
[Python] Comment supprimer les valeurs en double de la liste
Le mur lors du passage du service Django de Python 2.7 à la série Python 3
Comment écrire une interface graphique à l'aide de la commande maya
Étapes de l'installation de Django à l'affichage de la page html
[CRUD] [Django] Créer un site CRUD en utilisant le framework Python Django ~ 1 ~
Envoyer les données du journal du serveur vers Splunk Cloud
Comment utiliser le stockage Azure Table de Django (PTVS)
Backtrader Comment importer un indicateur depuis un autre fichier
Comment créer un environnement Django (python) sur Docker
Comment lancer instantanément Jupyter Notebook à partir du terminal
Comment déployer une application Go sur une instance ECS
[Introduction à Udemy Python3 + Application] 27. Comment utiliser le dictionnaire
[CRUD] [Django] Créer un site CRUD en utilisant le framework Python Django ~ 2 ~
[Introduction à Udemy Python3 + Application] 30. Comment utiliser l'ensemble
[Introduction à Python] Comment arrêter la boucle en utilisant break?
Comment publier un ticket depuis l'API Shogun