[DOCKER] Tutoriel Django (Créer une application de blog) ① --Préparation, Création de la première page

Cette fois, nous utiliserons Django pour créer une application de blog qui vous permet de publier des articles.

Nous l'introduirons en série, mais nous allons d'abord le créer localement, puis le configurer dans une configuration Docker, le déployer sur AWS et utiliser CircleCI pour créer une série de tests et de déploiements automatisés.

Qu'est-ce que Django?

Django est un framework d'application Web qui peut être implémenté en Python.

Un framework est un logiciel qui est un ensemble de fonctions utilisées lors du développement d'une application. En introduisant le framework, vous pouvez utiliser l'application Web de manière efficace.

Cette fois, nous allons créer une application Blog, mais avec Django, vous pouvez facilement créer des applications Web de haute qualité telles que des systèmes de gestion de contenu et des wikis, des réseaux sociaux, des sites d'actualités, etc. en utilisant des bases de données avec moins de code. Une simple application Web peut être créée en quelques minutes. Bien entendu, vous pouvez étendre les fonctionnalités pour créer des applications Web complexes.

Django est également utilisé dans des applications Web bien connues telles qu'Instagram, et est devenu un framework notable équivalent à Ruby on Rails dans Ruby.

Environnement

Commencez par créer un répertoire de travail. Le nom ici peut être n'importe quoi, mais pour l'instant, appelons-le blog.

mkdir blog
cd blog

Installation de pipenv

Si vous ne polluez pas l'environnement de base, vous pouvez éliminer l'influence d'autres modules, alors construisons un environnement virtuel en utilisant pipenv.

pip install pipenv
#Selon l'environnement, vous ne pourrez peut-être pas utiliser pip directement, donc python3-Installer avec m pip installer pipenv

Après l'installation, exécutez la commande suivante dans le dossier de travail.

pipenv shell

Après l'exécution, lorsque vous pouvez entrer dans l'environnement virtuel, la chaîne de caractères correspondant au nom du répertoire s'affiche au début de la ligne de commande.

(blog)bash-3.2$

Installez Django

Vous pouvez également lancer pipenv install django directement pour installer Django, Si vous envisagez d'utiliser Docker plus tard, créez un fichier appelé requirements.txt directement sous le répertoire de travail. Je décrirai les modules nécessaires.

Pour le moment, je n'ai besoin que de Django, donc je vais l'écrire avec les informations de version comme suit:

requirements.txt

Django==3.1.0

• Cette fois, je vais le faire avec Django 3.1.0, mais je pense que cela fonctionnera sans problème même autour de Django 2.2.

Installation du module

Installez le module en fonction de requirements.txt en exécutant la commande suivante. Seul Django doit être installé ici.

pipenv install -r requirements.txt

Créer un projet Django

Exécutez directement sous le répertoire du blog

django-admin startproject mysite

Je pense que la structure du fichier directement sous le projet parent ressemble à ceci.

├── Pipfile
├── Pipfile.lock
├── mysite
│   ├── manage.py
│   └── mysite
│       ├── __init__.py
│       ├── settings.py
│       ├── urls.py
│       └── wsgi.py
└── requirements.txt

Test de lancement du serveur Django

Il a une fonction pour démarrer le serveur de développement. (Si vous avez fait Ruby on Rails, les rails -s devraient être faciles à comprendre.)

Pour ce faire, il est plus pratique d'aller dans le répertoire où se trouve le fichier manage.py, alors allez dans le répertoire mysite / mysite avant de l'exécuter.

cd mysite
python3 manage.py runserver

S'il peut être exécuté normalement, la sortie suivante sera sortie.

October 16, 2020 - 21:30:23
Django version 3.1, using settings 'mysite.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Notez que cette partie est un message qui est généré car le processus d'intégration à la base de données appelée migrate n'est pas terminé, mais pour l'instant, il est normal de ne pas s'en soucier.

You have 18 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.

Maintenant que le serveur de développement Django a démarré, vérifiez-le depuis votre navigateur. Tapez 127.0.0.1:8000 dans la barre d'adresse d'un navigateur tel que Chrome et appuyez sur Entrée.

C'est le début de tout. Si vous voyez cet écran, la première étape est terminée! Toutes nos félicitations.

Paramètres du projet

À propos, lorsque vous avez accédé au serveur de test plus tôt, il était rédigé en anglais. Ces paramètres peuvent être définis dans mysite / settings.py, et par défaut, l'affichage de la langue et le fuseau horaire sont adaptés au monde anglophone.

mysite/settings.py(before)

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

Je vais changer cela comme suit.

mysite/settings.py(after)

LANGUAGE_CODE = 'ja'

TIME_ZONE = 'Asia/Tokyo'

Si vous accédez à nouveau au serveur de test, vous verrez qu'il est écrit en japonais. (Bien que cela ne puisse pas être confirmé à partir de cet écran, le fuseau horaire est également défini sur Tokyo)

Créer une application Django

J'ai créé un projet avec la commande start-project plus tôt, mais ensuite je vais créer une application. Il est facile de se confondre, mais le projet sous-jacent et les applications individuelles sont différents.

C'est l'explication sur la page officielle.

Quelle est la différence entre un projet et une application? Une application est une application Web qui fait quelque chose, comme un système de blog, une base de données de documents publics ou une petite application de vote. Un projet est un ensemble de configurations de sites Web et d'applications spécifiques. Un projet peut contenir plusieurs applications. L'application peut exister dans plusieurs projets.

Créons maintenant une application de blog. Exécutez la commande suivante directement sous le projet mysite (où se trouve le fichier manage.py).

python3 manage.py startapp blog

La structure actuelle des répertoires ressemble à ceci.

.
├── db.sqlite3
├── manage.py
├── mysite
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── blog
    ├── __init__.py
    ├── admin.py
    ├── apps.py
    ├── migrations
    │   └── __init__.py
    ├── models.py
    ├── tests.py
    └── views.py

Vous pouvez voir que divers fichiers sont créés sous le blog.

Nous devons maintenant indiquer au projet que cette application a été créée.

Il y a une colonne appelée "INSTALLED_APPS" dans mysite / setting.py, nous allons donc vous dire l'existence de l'application de blog.

mysite/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog.apps.BlogConfig', #Ajouter ici
]

modèle, vue, paramètres d'URL

Premièrement, "changez chaque modèle.

Le modèle est la partie qui crée l'apparence et correspond au fichier html.

Créez un dossier de modèles directement sous le projet mysite, un dossier de blog en dessous et index.html en dessous.

.
├── blog
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── migrations
│   │   └── __init__.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
├── db.sqlite3
├── manage.py
├── mysite
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── templates
    └── blog
        └── index.html ← Créez ici

Le contenu de index.html est approprié pour le moment.

index.html

<h1>Hello, from Django!</h1>

Vous devez également indiquer au projet où vous avez créé le dossier de modèles. Tout comme lorsque vous définissez INSTALLED_APPS, placez ce qui suit dans settings.py.

settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')], #Fixez ici
        'APP_DIRS': True,

Ensuite, modifiez views.py. Appelez index.html, le modèle que vous avez créé précédemment.

blog/views.py

from django.views.generic import TemplateView

class IndexView(TemplateView):
    template_name = 'blog/index.html'

Conception d'URL

Ensuite, créez un paramètre de routage spécifiquement pour l'application de blog. Les paramètres de routage sont définis dans un fichier appelé "urls.py".

Tout d'abord, définissez le routage dans urls.py, qui contrôle le routage de l'ensemble du projet, et urls.py dans l'application.

Tout d'abord, éditez à partir de urls.py directement sous mysite.

mysite/urls.py

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('blog/', include('blog.urls')),
    path('admin/', admin.site.urls),
]

Vous allez charger les URL de l'application de blog que vous créerez plus tard dans les modèles d'url.

Dans, urls.py n'est créé que directement sous mysite, mais vous pouvez également créer "urls.py" directement sous blog. Vous pouvez utiliser un éditeur ou exécuter la commande suivante dans le répertoire du blog de l'application.

/blog

touch urls.py

La structure des fichiers sous blog est comme ça.

.
├── __init__.py
├── admin.py
├── apps.py
├── migrations
│   └── __init__.py
├── models.py
├── tests.py
├── urls.py
└── views.py

En modifiant le contenu des urls.py créées de cette manière, vous pouvez définir le routage de la fonction créée dans views.py (= le processus d'appel de index.html).

blog/urls.py

from django.urls import path
from . import views

app_name = 'blog'

urlpatterns = [
    path('', views.IndexView.as_view(), name='index'),
]

En passant, en définissant name = 'index', vous pouvez appeler cette URL par recherche inversée en utilisant le nom "blog: index".

À ce stade, vérifiez si index.html peut être appelé.

Exécutez runserver dans le répertoire où se trouve manage.py.

python3 manage.py runserver

Si vous réussissez, accédez à ** 127.0.0.1:8000/blog ** avec votre navigateur. En effet, le contenu décrit dans l'application de blog fonctionne lorsqu'il est accédé avec l'adresse avec blog dans mysite / urls.py plus tôt.

Si vous y accédez et que le contenu de index.html est affiché, cela réussit.

La prochaine fois, nous créerons des modèles et nous préparerons à enregistrer l'article.

→ Suite: Tutoriel Django (création d'application de blog) ② - création de modèles, préparation du site de gestion