Django Zelfstudie
Aan de slag met Django

Opmerkingen

versies

Een project starten

Django is een raamwerk voor webontwikkeling op basis van Python. Django 1.11 (de nieuwste stabiele release) vereist dat Python 2.7 , 3.4 , 3.5 of 3.6 is geïnstalleerd. Ervan uitgaande dat pip beschikbaar is, is de installatie zo eenvoudig als het uitvoeren van de volgende opdracht. Houd er rekening mee dat als u de hieronder weergegeven versie weglaat, de nieuwste versie van django wordt geïnstalleerd:

$ pip install django

Voor de installatie van een specifieke versie van django, laten we aannemen dat de versie django 1.10.5 is , voert u de volgende opdracht uit:

$ pip install django==1.10.5

Webapplicaties gebouwd met Django moeten deel uitmaken van een Django-project. U kunt de opdracht django-admin gebruiken om een nieuw project in de huidige map te starten:

$ django-admin startproject myproject

waarbij myproject een naam is die het project uniek identificeert en kan bestaan uit cijfers , letters en onderstrepingstekens .

Dit zal de volgende projectstructuur creëren:

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

Start de ontwikkelingsserver om de toepassing uit te voeren

$ cd myproject
$ python manage.py runserver

Nu de server actief is, gaat u met uw webbrowser naar http://127.0.0.1:8000/ . U ziet de volgende pagina:

Standaard start de opdracht runserver de ontwikkelingsserver op het interne IP-adres op poort 8000 . Deze server wordt automatisch opnieuw gestart als u wijzigingen aanbrengt in uw code. Maar als u nieuwe bestanden toevoegt, moet u de server handmatig opnieuw opstarten.

Als u de poort van de server wilt wijzigen, geeft u deze door als opdrachtregelargument.

$ python manage.py runserver 8080

Als u het IP-adres van de server wilt wijzigen, geeft u dit door aan de poort.

$ python manage.py runserver 0.0.0.0:8000

Merk op dat runserver alleen runserver is voor debug builds en lokale testen. Gespecialiseerde serverprogramma's (zoals Apache) moeten altijd in de productie worden gebruikt.

Een Django-app toevoegen

Een Django-project bevat meestal meerdere apps . Dit is gewoon een manier om uw project te structureren in kleinere, onderhoudbare modules. Om een app te maken, gaat u naar uw projectmap (waar manage.py is) en voert u de opdracht startapp uit (wijzig myapp naar wat u maar wilt):

python manage.py startapp myapp

Hiermee worden de map myapp en enkele benodigde bestanden voor u gegenereerd, zoals models.py en views.py .

Om Django bewust te maken van myapp , voeg je deze toe aan je settings.py :

# myproject/settings.py

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

De mappenstructuur van een Django-project kan worden aangepast aan uw voorkeur. Soms wordt de naam van de projectmap gewijzigd in /src om te voorkomen dat mapnamen worden herhaald. Een typische mapstructuur ziet er zo uit:

Django-concepten

django-admin is een opdrachtregelprogramma dat wordt geleverd met Django. Het wordt geleverd met verschillende handige opdrachten om aan de slag te gaan met en een Django-project te beheren. De opdracht is hetzelfde als ./manage.py , met het verschil dat u niet in de projectmap hoeft te staan. De omgevingsvariabele DJANGO_SETTINGS_MODULE moet worden ingesteld.

Een Django-project is een Python-codebase die een Django-instellingenbestand bevat. Een project kan door de Django-beheerder worden gemaakt met het commando django-admin startproject NAME . Het project heeft meestal een bestand met de naam manage.py op het hoogste niveau en een root-URL-bestand met de naam urls.py manage.py is een projectspecifieke versie van django-admin , waarmee u beheeropdrachten voor dat project kunt uitvoeren. Gebruik bijvoorbeeld python manage.py runserver om uw project lokaal uit te python manage.py runserver . Een project bestaat uit Django-apps.

Een Django-app is een Python-pakket dat een models.py (standaard models.py ) en andere bestanden bevat, zoals app-specifieke urls en views. Een app kan worden gemaakt met de opdracht django-admin startapp NAME (deze opdracht moet worden uitgevoerd vanuit uw projectmap). Een app kan alleen deel uitmaken van een project als deze is opgenomen in de lijst INSTALLED_APPS in settings.py . Als je de standaardconfiguratie hebt gebruikt, wordt Django geleverd met verschillende vooraf geïnstalleerde apps met eigen apps die zaken als authenticatie voor je afhandelen. Apps kunnen in meerdere Django-projecten worden gebruikt.

De Django ORM verzamelt alle databasemodellen die zijn gedefinieerd in models.py en maakt databasetabellen op basis van die models.py . Stel eerst uw database in door de DATABASES instelling in settings.py te settings.py . Nadat u uw databasemodellen hebt gedefinieerd, voert u python manage.py makemigrations gevolgd door python manage.py migrate het schema van uw database op basis van uw modellen te maken of bij te werken.

Een compleet voorbeeld van hallo wereld.

Stap 1 Als u Django al heeft geïnstalleerd, kunt u deze stap overslaan.

pip install Django

Stap 2 Maak een nieuw project

django-admin startproject hello

Dat zal een map met de naam hello die de volgende bestanden zal bevatten:

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

Stap 3 Maak in de hello module (de map met de __init.py__ ) een bestand met de naam views.py :

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

en plaats de volgende inhoud:

from django.http import HttpResponse

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

Dit wordt een weergavefunctie genoemd.

Stap 4 Bewerk hello/urls.py als volgt:

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

die de weergavefunctie hello() koppelt aan een URL.

Stap 5 Start de server.

python manage.py runserver

Stap 6

Blader naar http://localhost:8000/ in een browser en u ziet:

Hallo Wereld

Virtuele omgeving

Hoewel niet strikt vereist, wordt het ten zeerste aanbevolen om uw project in een "virtuele omgeving" te starten. Een virtuele omgeving is een container (een map) die een specifieke versie van Python en een set modules (afhankelijkheden) bevat en die de native Python van het besturingssysteem of andere projecten op dezelfde computer niet verstoort.

Door een verschillende virtuele omgeving in te stellen voor elk project waaraan u werkt, kunnen verschillende Django-projecten op verschillende versies van Python draaien en hun eigen sets van afhankelijkheden behouden, zonder risico op conflicten.

Python 3.3+

Python 3.3+ bevat al een standaard venv module, die u meestal pyvenv kunt noemen. In omgevingen waar de opdracht pyvenv niet beschikbaar is, hebt u toegang tot dezelfde functionaliteit door de module rechtstreeks aan te roepen als python3 -m venv .

De virtuele omgeving maken:

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

Python 2

Als u Python 2 gebruikt, kunt u het eerst installeren als een afzonderlijke module van pip:

$ pip install virtualenv

En maak vervolgens de omgeving met de opdracht virtualenv :

$ virtualenv <env-folder>

Activeren (elke versie)

De virtuele omgeving is nu ingesteld. Om het te gebruiken, moet het worden geactiveerd in de terminal die u wilt gebruiken.

De virtuele omgeving (elke Python-versie) 'activeren'

Linux zoals:

$ source <env-folder>/bin/activate

Windows zoals:

<env-folder>\Scripts\activate.bat

Hiermee wordt uw prompt gewijzigd om aan te geven dat de virtuele omgeving actief is. (<env-folder>) $

Vanaf nu wordt alles dat met pip is geïnstalleerd, geïnstalleerd in uw virtuele env-map, niet in het hele systeem.

Gebruik deactivate om de virtuele omgeving te verlaten:

(<env-folder>) $ deactivate

Alternatief: gebruik virtualenvwrapper

Je kunt ook overwegen om virtualenvwrapper te gebruiken, wat het maken en activeren van virtualenv erg handig maakt en het van je code scheidt:

# Create a virtualenv
mkvirtualenv my_virtualenv

# Activate a virtualenv
workon my_virtualenv

# Deactivate the current virtualenv
deactivate

Alternatief: gebruik pyenv + pyenv-viritualenv

In omgevingen waar u meerdere Python-versies moet verwerken, kunt u profiteren van virtualenv samen met pyenv-virtualenv:

# 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

Bij het gebruik van virtualenvs is het vaak handig om uw PYTHONPATH en DJANGO_SETTINGS_MODULE in te DJANGO_SETTINGS_MODULE in het 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"

Stel uw projectpad in

Het is vaak ook nuttig om uw projectpad in een speciaal .project bestand in uw basis <env-folder> . Wanneer u dit doet, wordt elke keer dat u uw virtuele omgeving activeert, de actieve map gewijzigd in het opgegeven pad.

Maak een nieuw bestand met de naam <env-folder>/.project . De inhoud van het bestand mag ALLEEN het pad van de projectmap zijn.

/path/to/project/directory

workon my_virtualenv nu uw virtuele omgeving (met behulp van source <env-folder>/bin/activate workon my_virtualenv of workon my_virtualenv ) en uw terminal zal van map veranderen in /path/to/project/directory .

Eén bestand Hallo wereld voorbeeld

Dit voorbeeld toont u een minimale manier om een Hello World-pagina in Django te maken. Dit helpt je te beseffen dat de opdracht django-admin startproject example feite een aantal mappen en bestanden maakt en dat je die structuur niet noodzakelijkerwijs nodig hebt om je project uit te voeren.

1. Maak een bestand met de naam file.py

2. Kopieer en plak de volgende code in dat bestand.

    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. Ga naar de terminal en voer het bestand uit met deze opdracht python file.py runserver .

4. Open uw browser en ga naar 127.0.0.1:8000 .

Implementatievriendelijk project met Docker-ondersteuning.

De standaard Django-projectsjabloon is prima, maar als je eenmaal je code hebt geïmplementeerd en bijvoorbeeld devops het project in handen hebt, wordt het rommelig. Wat u kunt doen, is uw broncode scheiden van de rest die in uw repository moet staan.

Je kunt een bruikbaar Django-projectsjabloon vinden op GitHub .

Project structuur

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

Ik wil het houden service map met de naam service voor elk project dankzij dat ik hetzelfde kan gebruiken Dockerfile over al mijn projecten. De splitsing van vereisten en instellingen is hier al goed gedocumenteerd:
Meerdere vereiste bestanden gebruiken
Meerdere instellingen gebruiken

Dockerfile

In de veronderstelling dat alleen ontwikkelaars gebruik maken van Docker (niet elke ontwikkelaar vertrouwt het tegenwoordig). Dit kan een ontwikkelomgeving 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"]

Als u alleen vereisten toevoegt, wordt Docker-cache gebruikt tijdens het bouwen - u hoeft alleen opnieuw op te bouwen bij het wijzigen van vereisten.

Componeren

Docker compose is handig - vooral als u meerdere services lokaal wilt uitvoeren. 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

Je ontwikkelomgeving moet zo dicht mogelijk bij de prod-omgeving staan, dus ik gebruik Nginx vanaf het begin. Hier is een voorbeeld van een nginx-configuratiebestand:

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/;
    }
}

Gebruik

$ 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