Django Tutorial
Erste Schritte mit Django

Bemerkungen

Versionen

Projekt starten

Django ist ein auf Python basierendes Webentwicklungs-Framework. Django 1.11 (die neueste stabile Version) erfordert die Installation von Python 2.7 , 3.4 , 3.5 oder 3.6 . Vorausgesetzt, pip ist verfügbar, ist die Installation so einfach wie das Ausführen des folgenden Befehls. Denken Sie daran, wenn Sie die Version wie unten gezeigt weglassen, wird die neueste Version von django installiert:

$ pip install django

Nehmen Sie zur Installation einer bestimmten Version von django an, dass die Version django 1.10.5 ist. Führen Sie den folgenden Befehl aus:

$ pip install django==1.10.5

Webanwendungen, die mit Django erstellt wurden, müssen sich in einem Django-Projekt befinden. Sie können den Befehl django-admin , um ein neues Projekt im aktuellen Verzeichnis zu starten:

$ django-admin startproject myproject

Dabei ist myproject Projekt ein Name, der das Projekt eindeutig identifiziert und aus Zahlen , Buchstaben und Unterstrichen bestehen kann .

Dadurch wird die folgende Projektstruktur erstellt:

myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        wsgi.py

Starten Sie den Entwicklungsserver, um die Anwendung auszuführen

$ cd myproject
$ python manage.py runserver

Nun, da der Server läuft, besuchen Sie http://127.0.0.1:8000/ mit Ihrem Webbrowser. Sie sehen die folgende Seite:

runserver Befehl runserver startet standardmäßig den Entwicklungsserver auf der internen IP- runserver an Port 8000 . Dieser Server wird automatisch neu gestartet, wenn Sie Änderungen an Ihrem Code vornehmen. Falls Sie jedoch neue Dateien hinzufügen, müssen Sie den Server manuell neu starten.

Wenn Sie den Port des Servers ändern möchten, übergeben Sie ihn als Befehlszeilenargument.

$ python manage.py runserver 8080

Wenn Sie die IP des Servers ändern möchten, übergeben Sie diese zusammen mit dem Port.

$ python manage.py runserver 0.0.0.0:8000

Der runserver ist nur für runserver und lokale Tests runserver . Spezielle Serverprogramme (wie Apache) sollten in der Produktion immer verwendet werden.

Hinzufügen einer Django-App

Ein Django-Projekt enthält normalerweise mehrere apps . Dies ist einfach eine Möglichkeit, Ihr Projekt in kleinere, wartbare Module zu strukturieren. Um eine App zu erstellen, gehen Sie zu Ihrem Projektordner (dort, wo sich manage.py befindet) und führen Sie den Befehl startapp (ändern Sie myapp in einen beliebigen Bereich)

python manage.py startapp myapp

Daraufhin werden der myapp- Ordner und einige für Sie notwendige Dateien wie models.py und views.py .

Um Django auf myapp aufmerksam zu machen , fügen Sie es zu Ihren settings.py hinzu.py :

# myproject/settings.py

# Application definition
INSTALLED_APPS = [
    ...
    'myapp',
]

Die Ordnerstruktur eines Django-Projekts kann nach Ihren Wünschen geändert werden. Manchmal wird der Projektordner in /src , um die Wiederholung von /src zu vermeiden. Eine typische Ordnerstruktur sieht folgendermaßen aus:

Django-Konzepte

django-admin ist ein Befehlszeilentool, das mit Django geliefert wird. Es enthält mehrere nützliche Befehle, um ein Django-Projekt zu beginnen und zu verwalten. Der Befehl ist dasselbe wie ./manage.py , mit dem Unterschied, dass Sie sich nicht im Projektverzeichnis befinden müssen. Die Umgebungsvariable DJANGO_SETTINGS_MODULE muss gesetzt werden.

Ein Django-Projekt ist eine Python-Codebasis, die eine Django-Einstellungsdatei enthält. Ein Projekt kann vom Django-Administrator mit dem Befehl django-admin startproject NAME . Das Projekt hat normalerweise eine Datei namens manage.py auf der obersten Ebene und eine Stamm-URL-Datei namens urls.py manage.py ist eine projektspezifische Version von django-admin , mit der Sie Verwaltungsbefehle für dieses Projekt ausführen können. Verwenden Sie beispielsweise python manage.py runserver , um Ihr Projekt lokal python manage.py runserver . Ein Projekt besteht aus Django-Apps.

Eine Django-App ist ein Python-Paket, das eine Models-Datei ( models.py standardmäßig) und andere Dateien wie app-spezifische URLs und Ansichten enthält. Eine App kann mit dem Befehl django-admin startapp NAME (dieser Befehl sollte in Ihrem Projektverzeichnis ausgeführt werden). Damit eine App Teil eines Projekts ist, muss sie in der Liste INSTALLED_APPS in der INSTALLED_APPS settings.py . Wenn Sie die Standardkonfiguration verwendet haben, werden bei Django mehrere Apps seiner eigenen Apps vorinstalliert, die beispielsweise Authentifizierung für Sie erledigen. Apps können in mehreren Django-Projekten verwendet werden.

Der Django-ORM erfasst alle in models.py definierten models.py und erstellt basierend auf diesen Modellklassen Datenbanktabellen. Richten Sie dazu zunächst Ihre Datenbank ein, indem Sie die Einstellung DATABASES in settings.py DATABASES . python manage.py makemigrations Sie Ihre Datenbankmodelle definiert haben, führen Sie anschließend python manage.py makemigrations gefolgt von python manage.py migrate , um das Schema Ihrer Datenbank basierend auf Ihren Modellen zu erstellen oder zu aktualisieren.

Ein komplettes Hallo Weltbeispiel.

Schritt 1 Wenn Sie Django bereits installiert haben, können Sie diesen Schritt überspringen.

pip install Django

Schritt 2 Erstellen Sie ein neues Projekt

django-admin startproject hello

Daraufhin wird ein Ordner mit dem Namen hello der die folgenden Dateien enthält:

hello/
├── hello/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

Schritt 3 Im Inneren des hello - Modul (der Ordner , die enthalten __init.py__ ) erstellen eine Datei namens views.py :

hello/
├── hello/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── views.py  <- here
│   └── wsgi.py
└── manage.py

und füge folgenden Inhalt hinzu:

from django.http import HttpResponse

def hello(request):
    return HttpResponse('Hello, World')

Dies wird als Ansichtsfunktion bezeichnet.

Schritt 4 Bearbeiten Sie hello/urls.py wie folgt:

from django.conf.urls import url
from django.contrib import admin
from hello import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^$', views.hello)
]

welche die View-Funktion hello() mit einer URL verknüpft.

Schritt 5 Starten Sie den Server.

python manage.py runserver

Schritt 6

Navigieren Sie in einem Browser zu http://localhost:8000/ und Sie werden sehen:

Hallo Welt

Virtuelle Umgebung

Obwohl dies nicht unbedingt erforderlich ist, wird dringend empfohlen, Ihr Projekt in einer "virtuellen Umgebung" zu starten. Eine virtuelle Umgebung ist ein Container (ein Verzeichnis), das eine bestimmte Version von Python und eine Reihe von Modulen (Abhängigkeiten) enthält und der native Python des Betriebssystems oder andere Projekte auf demselben Computer nicht beeinträchtigt.

Durch das Einrichten einer anderen virtuellen Umgebung für jedes Projekt, an dem Sie arbeiten, können verschiedene Django-Projekte auf verschiedenen Python-Versionen ausgeführt werden und können ihre eigenen Abhängigkeiten beibehalten, ohne dass dies zu Konflikten führt.

Python 3.3+

Python 3.3+ enthält bereits ein Standard- venv Modul, das Sie normalerweise als pyvenv aufrufen pyvenv . In Umgebungen, in denen der Befehl pyvenv nicht verfügbar ist, können Sie auf die gleiche Funktionalität zugreifen, indem Sie das Modul direkt als python3 -m venv .

So erstellen Sie die virtuelle Umgebung:

$ pyvenv <env-folder>
# Or, if pyvenv is not available
$ python3 -m venv <env-folder>

Python 2

Wenn Sie Python 2 verwenden, können Sie es zunächst als separates Modul von pip installieren:

$ pip install virtualenv

Erstellen Sie anschließend die Umgebung mit dem Befehl virtualenv :

$ virtualenv <env-folder>

Aktivieren (beliebige Version)

Die virtuelle Umgebung ist jetzt eingerichtet. Um es verwenden zu können, muss es in dem Terminal aktiviert werden, das Sie verwenden möchten.

So aktivieren Sie die virtuelle Umgebung (jede Python-Version)

Linux wie:

$ source <env-folder>/bin/activate

Windows wie:

<env-folder>\Scripts\activate.bat

Dadurch wird Ihre Aufforderung geändert, um anzuzeigen, dass die virtuelle Umgebung aktiv ist. (<env-folder>) $

Von jetzt an wird alles, was mit pip installiert wurde, in Ihrem virtuellen Ordner env installiert, nicht systemweit.

Um die virtuelle Umgebung zu verlassen, deactivate :

(<env-folder>) $ deactivate

Alternativ: Verwenden Sie virtualenvwrapper

Sie können auch den Einsatz von virtualenvwrapper in Betracht ziehen, was die Erstellung und Aktivierung von virtualenv sehr praktisch macht und von Ihrem Code trennt:

# Create a virtualenv
mkvirtualenv my_virtualenv

# Activate a virtualenv
workon my_virtualenv

# Deactivate the current virtualenv
deactivate

Alternativ: Verwenden Sie pyenv + pyenv-viritualenv

In Umgebungen, in denen Sie mit mehreren Python-Versionen arbeiten müssen, können Sie gemeinsam mit pyenv-virtualenv von virtualenv profitieren:

# Create a virtualenv for specific Python version
pyenv virtualenv 2.7.10 my-virtual-env-2.7.10

# Create a vritualenv for active python verion
pyenv virtualenv venv34

# Activate, deactivate virtualenv
pyenv activate <name>
pyenv deactivate

Bei der Verwendung von Virtualenvs ist es oft nützlich, PYTHONPATH und DJANGO_SETTINGS_MODULE im postactivate Skript postactivate .

#!/bin/sh
# This hook is sourced after this virtualenv is activated

# Set PYTHONPATH to isolate the virtualenv so that only modules installed
# in the virtualenv are available
export PYTHONPATH="/home/me/path/to/your/project_root:$VIRTUAL_ENV/lib/python3.4"

# Set DJANGO_SETTINGS_MODULE if you don't use the default `myproject.settings`
# or if you use `django-admin` rather than `manage.py`
export DJANGO_SETTINGS_MODULE="myproject.settings.dev"

Legen Sie Ihren Projektpfad fest

Oft ist es auch hilfreich, den Projektpfad in einer speziellen .project , die sich in Ihrem <env-folder> . Bei jeder Aktivierung Ihrer virtuellen Umgebung ändert das aktive Verzeichnis den angegebenen Pfad.

Erstellen Sie eine neue Datei mit dem Namen <env-folder>/.project . Der Inhalt der Datei sollte NUR der Pfad des Projektverzeichnisses sein.

/path/to/project/directory

workon my_virtualenv nun Ihre virtuelle Umgebung (entweder mit dem workon my_virtualenv source <env-folder>/bin/activate workon my_virtualenv source <env-folder>/bin/activate workon my_virtualenv oder workon my_virtualenv ), und Ihr Terminal wechselt in das Verzeichnis /path/to/project/directory .

Hello World-Beispiel für eine Datei

Dieses Beispiel zeigt Ihnen, wie Sie in Django eine Hello World-Seite erstellen. Dies hilft Ihnen zu erkennen, dass der Beispielbefehl django-admin startproject example Wesentlichen eine Reihe von Ordnern und Dateien erstellt und dass Sie nicht unbedingt diese Struktur zum Ausführen Ihres Projekts benötigen.

1. Erstellen Sie eine Datei namens file.py

2. Kopieren Sie den folgenden Code und fügen Sie ihn in diese Datei ein.

    import sys
    
    from django.conf import settings
    
    settings.configure(
        DEBUG=True,
        SECRET_KEY='thisisthesecretkey',
        ROOT_URLCONF=__name__,
        MIDDLEWARE_CLASSES=(
            'django.middleware.common.CommonMiddleware',
            'django.middleware.csrf.CsrfViewMiddleware',
            'django.middleware.clickjacking.XFrameOptionsMiddleware',
        ),
    )
    
    from django.conf.urls import url
    from django.http import HttpResponse
    
    # Your code goes below this line.
   
    def index(request):
        return HttpResponse('Hello, World!')
   
    urlpatterns = [
        url(r'^$', index),
    ]
   
    # Your code goes above this line
    
    if __name__ == "__main__":
        from django.core.management import execute_from_command_line
    
        execute_from_command_line(sys.argv)
   

3. Gehen Sie zum Terminal und führen Sie die Datei mit dem folgenden Befehl aus: python file.py runserver .

4. Öffnen Sie Ihren Browser und gehen Sie zu 127.0.0.1:8000 .

Bereitstellungsfreundliches Projekt mit Docker-Unterstützung.

Die Standardvorlage für das Django-Projekt ist in Ordnung, aber sobald Sie Ihren Code bereitstellen können, und zum Beispiel Devops ihre Hände auf das Projekt legen, wird es unordentlich. Was Sie tun können, ist, Ihren Quellcode von dem Rest zu trennen, der für Ihr Repository erforderlich ist.

Sie finden eine verwendbare Django-Projektvorlage auf GitHub .

Projektstruktur

PROJECT_ROOT
├── devel.dockerfile
├── docker-compose.yml
├── nginx
│   └── project_name.conf
├── README.md
├── setup.py
└── src
    ├── manage.py
    └── project_name
        ├── __init__.py
        └── service
            ├── __init__.py
            ├── settings
            │   ├── common.py
            │   ├── development.py
            │   ├── __init__.py
            │   └── staging.py
            ├── urls.py
            └── wsgi.py

Ich möchte das service namens service für jedes Projekt behalten, da ich in allen meinen Projekten dieselbe Dockerfile kann. Die Aufteilung der Anforderungen und Einstellungen ist hier bereits gut dokumentiert:
Verwendung mehrerer Anforderungsdateien
Mehrere Einstellungen verwenden

Dockerfile

Mit der Annahme, dass nur Entwickler Docker verwenden (heutzutage vertraut nicht jeder Entwickler). Dies könnte eine devel.dockerfile :

FROM python:2.7
ENV PYTHONUNBUFFERED 1

RUN mkdir /run/service
ADD . /run/service
WORKDIR /run/service

RUN pip install -U pip
RUN pip install -I -e .[develop] --process-dependency-links

WORKDIR /run/service/src
ENTRYPOINT ["python", "manage.py"]
CMD ["runserver", "0.0.0.0:8000"]

Wenn Sie nur Anforderungen hinzufügen, wird der Docker-Cache während der Erstellung genutzt. Sie müssen nur bei geänderten Anforderungen neu aufgebaut werden.

Komponieren

Docker Compose ist praktisch - vor allem, wenn Sie mehrere Dienste lokal ausführen müssen. docker-compose.yml :

version: '2'
services:
  web:
    build:
      context: .
      dockerfile: devel.dockerfile
    volumes:
      - "./src/{{ project_name }}:/run/service/src/{{ project_name }}"
      - "./media:/run/service/media"
    ports:
      - "8000:8000"
    depends_on:
      - db
  db:
    image: mysql:5.6
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE={{ project_name }}
  nginx:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - "./nginx:/etc/nginx/conf.d"
      - "./media:/var/media"
    depends_on:
      - web

Nginx

Ihre Entwicklungsumgebung sollte so nah wie möglich an der Produktumgebung sein, daher mag ich Nginx von Anfang an. Hier ist eine Beispiel-Nginx-Konfigurationsdatei:

server {
    listen   80;
    client_max_body_size 4G;
    keepalive_timeout 5;

    location /media/ {
        autoindex on;
        alias /var/media/;
    }

    location / {
        proxy_pass_header Server;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Ssl on;
        proxy_connect_timeout 600;
        proxy_read_timeout 600;
        proxy_pass http://web:8000/;
    }
}

Verwendungszweck

$ cd PROJECT_ROOT
$ docker-compose build web  # build the image - first-time and after requirements change
$ docker-compose up  # to run the project
$ docker-compose run --rm --service-ports --no-deps  # to run the project - and be able to use PDB
$ docker-compose run --rm --no-deps <management_command>  # to use other than runserver commands, like makemigrations
$ docker exec -ti web bash  # For accessing django container shell, using it you will be inside /run/service directory, where you can run ./manage shell, or other stuff
$ docker-compose start  # Starting docker containers
$ docker-compose stop  # Stopping docker containers