[PYTHON] So erstellen Sie eine Anwendung aus der Cloud mithilfe des Django-Webframeworks

In diesem Artikel erfahren Sie, wie Sie mit dem ** Django Web Framework ** eine Anwendung aus der Cloud erstellen, um Webentwicklern bei der Bewältigung der heutigen Herausforderungen zu helfen.

Warum Django?

Bevor wir über Django sprechen, möchte ich Ihnen sagen, was eine Webanwendung ist. Eine Webanwendung ist eine Sammlung von Code, der in einer Programmiersprache geschrieben ist, die in einem Browser gerendert wird und normalerweise genau definierte Probleme behebt. Zum Beispiel ein Blog-Beitrag (wie dieser!), Eine E-Commerce-Website oder ein soziales Netzwerk.

Nun, das ist ziemlich einfach, aber was ist ein Webframework? Ein Webframework ist eine Sammlung wiederverwendbarer Komponenten, die viele der allgemeinen und sich wiederholenden Aufgaben der Entwicklung von Webanwendungen auf integrierte Weise erledigen. Anstatt eine Bibliothek mit unterschiedlichem Code zu erhalten und einen Weg zu finden, wie diese zusammenarbeiten können, bietet das Webframework alle benötigten Komponenten in einem einzigen Paket und kümmert sich um die Integration. ..

Nachdem Sie das Konzept von Web-Apps und Frameworks kennen, sprechen wir über Django. Django ist eines der neuesten Web-Frameworks, das die Erstellung von Web-Apps vereinfachen soll. Django bietet eine Reihe von Tools, mit denen Sie schnell wiederverwendbare, skalierbare, saubere und hochdynamische Webanwendungen entwickeln können.

Django basiert auf dem DRY-Paradigma (Don't Repeat Yourself), und Sie müssen in jedem Schritt des Entwicklungsprozesses weniger Code schreiben als der durchschnittliche Code, der mit anderen Frameworks erforderlich ist. Es bedeutet nicht zu sein.

Diese Reihe von Tutorials führt Sie durch die Entwicklung mehrerer Anwendungen. Wie die verschiedenen mit Django gebündelten Komponenten und Anwendungen Ihnen helfen, in jeder Phase des Entwicklungsprozesses weniger Code zu schreiben. Hier erfahren Sie, wie Sie dies alles in der Cloud tun. Dieses Mal führen wir die Webanwendung auf einer Alibaba Cloud Elastic Compute Service (ECS) -Instanz aus. Das Verfahren zum Einrichten von Django auf ECS wird nicht beschrieben. Lesen Sie stattdessen die folgenden beiden Tutorials.

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

Projektdefinition

Das Projekt, das wir erstellen möchten, ist eine Webanwendung für den elektronischen Handel, mit der Menschen Waren kaufen und verkaufen können. Aus Gründen der Flexibilität und Wartbarkeit ist das Projekt in drei unabhängige Apps unterteilt: Kern-App, Warenkorb-App und Zahlungs-App.

Präsentation jeder Bewerbung

Kernanwendung

Wie bereits erwähnt, verwaltet die Kern-App alles (Ergänzungen, Änderungen, Löschungen), die mit dem Produkt zusammenhängen, das Sie verkaufen möchten. Die Kern-App zielt darauf ab, den gesamten Einkaufsprozess zu verwalten.

1, Benutzer (Käufer / Verkäufer und Administrator) 2, Produktinformationen 3, Produktkategorie

Wagenanwendung

Die Warenkorbanwendung wird verwendet, um den Kauf- und Verkaufsprozess zu verwalten. Die hier verwalteten spezifischen Elemente sind wie folgt.

1, Kauf- und Verkaufsoptionen 2, Warenkorb des Kunden und Warenkorbartikel 3, Artikel zum Warenkorb hinzufügen / entfernen

Zahlungsantrag

Die Zahlungs-App ermöglicht Ihnen den Zugriff auf das Zahlungs-Gateway und ermöglicht es Ihnen, das vom Kunden übergebene Geld zu erhalten. Hier klicken für Details:

1, Zahlungsgateway 2, Zahlungsmethode 3, Zahlungs-API-Integration

Einstellungen für die Entwicklungsumgebung

Installieren Sie Python 3 und Pip

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

Installieren der PostgreSQL-Datenbank

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

Virtualenv installieren

# sudo pip install virtualenv

Kisseninstallation Mit dieser Bibliothek können Sie Profile und Produktbilder auf Vorlagen drucken.

(venv)$ pip install pillow

Projektstart und Konfiguration

Erstellen und aktivieren Sie eine virtuelle Umgebung

Dieser Befehl erstellt eine virtuelle Umgebung im venv-Ordner, die python3 zum Standard-Python-Interpreter macht.

$ virtualenv venv --python=python3               
$ cd venv

Dieser Befehl aktiviert diese virtuelle Umgebung.

$ source bin/activate      

Installieren Sie Django in einer virtuellen Umgebung

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

Erstellen eines Django-Projekts

(venv)$ django-admin startproject buyandsell

Nach erfolgreichem Abschluss der oben genannten Schritte sollte der resultierende Projektordner folgendermaßen aussehen:

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

Hier sind einige der Dateien, die in diesem Ordner angezeigt werden.

1, ** settings.py **: Mit dieser Datei wird die Kernkonfiguration der App festgelegt, z. B. Datenbankzugriffsparameter und statische Dateidienstdefinitionen. 2, ** urls.py **: Mit dieser Datei wird ein URL-Stamm erstellt, der den von der Anwendung gespeicherten Inhalt bereitstellt. 3, ** wsgi.py **: Diese Datei definiert die Standardeinstellungen, die vom Webserver in den Bereitstellungseinstellungen verwendet werden. 4, ** manage.py **: Das Hauptskript zum Verwalten des Django-Projekts und seiner Anwendungen (Datenbankmigration, Testausführung, Ausführung des Entwicklungsservers). 5, ** db.sqlite3 **: Dies ist die in Django voreingestellte Standarddatenbank. Verwenden Sie es nur für die Entwicklung. Ändern Sie es jedoch bei der Bereitstellung in eine PostgreSQL-Datenbank, die in Verbindung mit der Django-Anwendung verwendet wird. 6, ** admin.py **: Wird zum Generieren einer Admin-Schnittstellenanwendung verwendet. 7, ** tests.py **: Definiert die Tests, die beim Testen der App ausgeführt werden sollen. 8, ** app.py **: Diese Datei enthält die Standardeinstellungen für die App.

Führen Sie eine erste Migration durch, um die Datenbank zu initialisieren

Nach dem Erstellen des Projekts müssen Sie grundlegende Tabellen wie Benutzer, Sitzung usw. erstellen, um das Standardverhalten von Django bereitzustellen.

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

Einen Superuser erstellen

Der Django-Superuser ist der Root-Benutzer von Linux, und dieser Benutzer hat alle Rechte an den in der Django-Datenbank gespeicherten Daten. Dieser Benutzer hat alle Zugriff auf die Administrationsoberfläche.

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

Hinweis: Bitte geben Sie ein 8-stelliges Passwort ein, das eine Mischung aus Groß- und Kleinbuchstaben und Sonderzeichen ist.

Testen Sie, ob die Anwendung ordnungsgemäß funktioniert

Sie können testen, ob es funktioniert, indem Sie einen Befehl im Ordner 'buyandsell'root ausgeben.

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

SERVER_IP ist die öffentliche IP-Adresse der Instanz der virtuellen Maschine und SERVER_PORT ist der auf dem Server konfigurierte externe Port.

Kernanwendungsentwicklung

Alle in diesem Tutorial entwickelten Anwendungen folgen dem folgenden Verfahren.

  1. Definieren Sie das Datenbankmodell in der Datei models.py.
  2. Definieren Sie die Ansichten, die die Anforderung verarbeiten, in der Datei views.py und erstellen Sie eine HTML-Vorlagendatei, mit der die Datei für den Endbenutzer gerendert wird.
  3. Verwenden Sie die Datei urls.py, um eine Route für Benutzer zum Navigieren in der Anwendung zu definieren.
  4. Verwenden Sie die Datei admin.py, um Einstellungen für die Administratorschnittstelle zu definieren, mit denen Anwendungsadministratoren die in der Datenbank gespeicherten Entitäten mühelos verwalten können. 5, dann passen Sie die Vorlage an, damit sie süßer aussieht.

Initialisierung der Kern-App

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

Nach der Initialisierung der Kern-App sollte der Projektordner einen neuen Ordner mit der folgenden Struktur haben:

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

Verknüpfen Sie Kern-Apps mit Kauf- und Verkaufsprojekten

Damit Django die Kern-App als Teil des buyandsell-Projekts betrachten kann, müssen Sie Ihrer Datei settings.py die folgenden Einstellungen hinzufügen:

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

Datenmodell

Wie oben erwähnt, behandelt diese App die folgenden Modelle.

1, Benutzerprofil 2, Produkt 3, Produktkategorie Und hier ist der entsprechende Quellcode.

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})

Nach dem Definieren des Modells müssen Sie diese Strukturen mit dem folgenden Befehl in der Datenbank speichern:

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

Ansichten und Vorlagendateien

Sie müssen Ansichten und Vorlagendateien definieren, damit Endbenutzer über Ihren Browser auf Ihre Anwendung zugreifen können.

Erstellen Sie Ansichten und Vorlagendateien, um die Modellerstellung, Aktualisierungen, Löschungen, Listen und Details zu verwalten.

Der Inhalt der Datei views.py wird unten angezeigt.

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"

Hier stellen wir die HTML-Vorlage vor, mit der das Formular zur Produkterstellung angezeigt wird.

{% 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 %}

Die HTML-Vorlagendatei befindet sich im Verzeichnis templates / core im Stammordner der Kernanwendung.

Weitere Informationen zur Verwendung von Django-Vorlagendateien finden Sie unter: django-website / templates

Routing mit URLConf

UrlConf ist eine Struktur, die definiert, wie die Navigation in Ihrer Anwendung erfolgt. Es wird in der Datei views.py festgelegt.

Unten ist der Inhalt dieser Datei.

# 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'),
]

Die bisher definierten Routen dienen als Einstiegspunkte für den Zugriff auf die im Ansichtsabschnitt definierten Vorlagendateien. Diese Datei erstellt eine Bindung zwischen dem URL-Pfad und der dieser URL zugeordneten Ansicht.

Administratoroberfläche

Wenn Sie eine Webanwendung erstellen, um die Geschäftsanforderungen Ihres Kunden zu erfüllen, erstellen Sie im Allgemeinen auch eine Administratoranwendung, die die in der Datenbank gespeicherten Daten, Berechtigungen, Berechtigungen und Rollen verwaltet. Django vereinfacht das Leben von Webentwicklern, da dies bereits standardmäßig erfolgt.

Um die Admin-Oberfläche zu konfigurieren, müssen Sie admin.py ändern und für die Verwendung des Modells konfigurieren.

Die Einstellungen werden auf diese Weise vorgenommen.

  1. Importieren Sie das Modell, das Sie der Administratoranwendung hinzufügen möchten, in die Datei admin.py.
from core.models import Product
  1. Erstellen Sie eine ModelAdmin-Klasse, die Ihr Modell verwaltet.
class ProductAdmin(admin.ModelAdmin):
pass
  1. Registrieren Sie die ModelAdmin-Klasse der Admin-Oberfläche mit einer der beiden folgenden Methoden: Verwenden Sie die Registrierungsmethode von admin.site
admin.site.register(Product, ProductAdmin)

Alternativ können Sie die Klasse ProductAdmin mit Anmerkungen versehen.

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

Verwenden Sie nach dem Wiederholen dieser Schritte für alle Modelle den folgenden Code in der Datei 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

Sobald dies erledigt ist, können Sie Ihren Browser unter der folgenden Adresse öffnen, um den Administratorbildschirm anzuzeigen.

127.0.0.1:8000/admin/

Sie haben sich mit dem in diesem Lernprogramm erstellten Superuser-Konto angemeldet.

App-Styling mit statischen Dateien

Jetzt, da wir eine funktionierende Anwendung haben, versuchen wir, einige Stile hinzuzufügen, um sie sichtbarer zu machen. Verwenden Sie also Bootstrap 3 und die Jquery-Bibliothek, um Ihrer Anwendung Stile hinzuzufügen.

Es gibt einen Prozess, um dies zu tun.

Laden Sie die entsprechende Quelldatei herunter.

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

Erstellen Sie einen Unterordner mit dem Namen static im Kernordner und einen weiteren Ordner mit dem Namen core darin. Platzieren Sie auf diese Weise die statischen Dateien der Kern-App in diesen Ordnern.

  1. Erstellen Sie einen CSS-Ordner zum Speichern der CSS-Datei
  2. Erstellen Sie einen js-Ordner, um die Javascript-Datei zu speichern 3, erstellen Sie einen Bildordner, um Bilder zu speichern

Legen Sie die Einstellungen STATIC_ROOT und STATIC_URL fest, um über Ihren Browser auf diese Dateien zuzugreifen

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

Konsolidieren Sie statische Dateien in der Datei base.html und stellen Sie diesen Bibliotheken geerbte Vorlagen zur Verfügung.

Laden Sie zunächst alle statischen Bibliotheken.

{% load static %}

Mit diesem Tag können Sie jetzt statische Ressourcen in statischen Ordnern verwenden, wie unten gezeigt.

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

Unten finden Sie die Datei base.html, die sich aus dem erfolgreichen Import aller statischen Ressourcen ergibt.

<!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>

Fazit

Am Ende dieses Tutorials erfahren Sie, wie Sie eine Anwendung mit dem Django-Webframework erstellen. Genauer gesagt haben wir die Modelle, Ansichten und Vorlagen von Django kennengelernt.

Der Quellcode für die in diesem Tutorial verwendete Anwendung befindet sich auf GitHub.

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

Recommended Posts

So erstellen Sie eine Anwendung aus der Cloud mithilfe des Django-Webframeworks
Versuchen Sie es mit Pythons Webframework Django (1) - Von der Installation bis zum Serverstart
Versuchen Sie es mit dem Webanwendungsframework Flask
So erstellen Sie einen Artikel über die Befehlszeile
(Python) Versuchen Sie, eine Webanwendung mit Django zu entwickeln
So stellen Sie eine Django-Anwendung in der Alibaba-Cloud bereit
[Lernnotiz] So erstellen Sie eine Anwendung mit Django ~ Von der virtuellen Umgebung bis zum Pushing zu Github ~
So schreiben Sie eine benutzerdefinierte Validierung in Django REST Framework
Versuchen Sie es mit dem Python-Webframework Django (2). Schauen Sie sich settings.py an
Zurücksetzen des Passworts über die API mit dem Django Rest Framework
So generieren Sie eine Abfrage mit dem IN-Operator in Django
So nehmen Sie erste Einstellungen für die Django-Projekterstellung vor
Wie man NAPALM aus dem Web erreicht (NetDevOpsSec echte Lösung)
Entwicklung einer WEB-Anwendung mit Django [Anwendungszusatz]
Erstellen Sie eine Webanwendung mit Django
Entwicklung einer WEB-Anwendung mit Django [Daten vom Verwaltungsbildschirm hinzufügen]
So erhalten Sie mithilfe der Mastodon-API Follower und Follower von Python
So stellen Sie eine Webanwendung in der Alibaba Cloud als Freiberufler bereit
Entwicklung einer WEB-Anwendung mit Django [Modelldefinition]
So überprüfen Sie die Version von Django
Entwicklung einer WEB-Anwendung mit Django [Request Processing]
Entwicklung einer WEB-Anwendung mit Django [Zusätzliche Vorlage]
So bedienen Sie Linux von der Konsole aus
Erstellen Sie eine Anwendung mit der Spotify-API
So greifen Sie von außen auf den Datenspeicher zu
Ich möchte DB mit Djangos ORM von einer externen Anwendung aus betreiben
[Django] So übergeben Sie Werte direkt von Vorlagen-Tags an JavaScript-Variablen
So beheben Sie die Probleme beim Lesen von Google Cloud Storage-Bildern von Django, die auf GAE bereitgestellt wurden
Versuchen Sie, Code aus 1 mit dem Framework Chainer für maschinelles Lernen (Mnist Edition) zu schreiben.
Lassen Sie uns mit Flask eine Webanwendung zur Konvertierung von A nach B erstellen! Von Grund auf neu ...
So öffnen Sie einen Webbrowser über Python
So erstellen Sie eine Umgebung für die Verwendung mehrerer Python-Versionen auf einem Mac
Entwicklung einer WEB-Anwendung mit Django [Erstellung des Admin-Bildschirms]
Ein Beispiel für cloudbuild.yaml bei der automatischen Bereitstellung von Django für App Engine mit Cloud Build
So rufen Sie die Cloud-API über GCP-Cloud-Funktionen auf
Versuchen Sie es mit dem Python-Webframework Tornado Part 1
So generieren Sie automatisch ein API-Dokument mit dem Django REST-Framework und POST vom Dokumentbildschirm
So drucken Sie Debug-Meldungen auf der Django-Konsole
Verwendung der Google Cloud Translation API
So bedienen Sie Linux von außen Vorgehensweise
So messen Sie die Leitungsgeschwindigkeit vom Terminal aus
Versuchen Sie es mit dem Python-Webframework Tornado Part 2
Anfänger versuchen mit Django + React + Bootstrap (1) eine Online-Webanwendung für Othello zu erstellen.
[Lernnotiz] So erstellen Sie eine App mit Django ~ Bis Hello World angezeigt wird ~
[Cloud 9] Versuchen Sie, eine Umgebung mit Django 1.11 von Python 3.4 zu erstellen, ohne auch nur 1 mm zu verstehen
[Python] So entfernen Sie doppelte Werte aus der Liste
Die Wand beim Ändern des Django-Dienstes von Python 2.7 auf Python 3-Serie
So schreiben Sie eine GUI mit dem Befehl maya
Schritte von der Installation von Django bis zur Anzeige der HTML-Seite
[CRUD] [Django] Erstellen Sie eine CRUD-Site mit dem Python-Framework Django ~ 1 ~
Senden Sie Protokolldaten vom Server an Splunk Cloud
Verwendung des Azure Table-Speichers von Django (PTVS)
Backtrader So importieren Sie einen Indikator aus einer anderen Datei
So erstellen Sie eine Django (Python) -Umgebung auf Docker
So starten Sie Jupyter Notebook sofort vom Terminal aus
So stellen Sie eine Go-Anwendung auf einer ECS-Instanz bereit
[Einführung in die Udemy Python3 + -Anwendung] 27. Verwendung des Wörterbuchs
[CRUD] [Django] Erstellen Sie eine CRUD-Site mit dem Python-Framework Django ~ 2 ~
[Einführung in die Udemy Python3 + -Anwendung] 30. Verwendung des Sets
[Einführung in Python] Wie stoppe ich die Schleife mit break?
So veröffentlichen Sie ein Ticket über die Shogun-API