Django Tutorial
Empezando con Django

Observaciones

Versiones

Comenzando un proyecto

Django es un framework de desarrollo web basado en Python. Django 1.11 (la última versión estable) requiere la instalación de Python 2.7 , 3.4 , 3.5 o 3.6 . Suponiendo que pip está disponible, la instalación es tan simple como ejecutar el siguiente comando. Tenga en cuenta que omitir la versión como se muestra a continuación instalará la última versión de django:

$ pip install django

Para instalar una versión específica de django, supongamos que la versión es django 1.10.5 , ejecute el siguiente comando:

$ pip install django==1.10.5

Las aplicaciones web creadas con Django deben residir dentro de un proyecto de Django. Puede usar el comando django-admin para iniciar un nuevo proyecto en el directorio actual:

$ django-admin startproject myproject

donde myproject es un nombre que identifica de forma única el proyecto y puede constar de números , letras y guiones bajos .

Esto creará la siguiente estructura de proyecto:

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

Para ejecutar la aplicación, inicie el servidor de desarrollo.

$ cd myproject
$ python manage.py runserver

Ahora que el servidor está funcionando, visite http://127.0.0.1:8000/ con su navegador web. Verás la siguiente página:

De forma predeterminada, el comando runserver inicia el servidor de desarrollo en la IP interna en el puerto 8000 . Este servidor se reiniciará automáticamente a medida que realice cambios en su código. Pero en caso de que agregue nuevos archivos, deberá reiniciar manualmente el servidor.

Si desea cambiar el puerto del servidor, páselo como un argumento de línea de comandos.

$ python manage.py runserver 8080

Si desea cambiar la IP del servidor, pásela junto con el puerto.

$ python manage.py runserver 0.0.0.0:8000

Tenga en cuenta que runserver es solo para compilaciones de depuración y pruebas locales. Los programas de servidor especializados (como Apache) siempre deben usarse en producción.

Añadiendo una aplicación Django

Un proyecto de Django usualmente contiene múltiples apps . Esta es simplemente una forma de estructurar su proyecto en módulos más pequeños y mantenibles. Para crear una aplicación, vaya a su carpeta de proyecto (donde manage.py es), y ejecute el comando startapp (cambie myapp a lo que quiera):

python manage.py startapp myapp

Esto generará la carpeta myapp y algunos archivos necesarios para usted, como models.py y views.py .

Para que Django sea consciente de myapp , agréguelo a su settings.py :

# myproject/settings.py

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

La estructura de carpetas de un proyecto de Django se puede cambiar para que se ajuste a sus preferencias. A veces, la carpeta del proyecto cambia de nombre a /src para evitar repetir los nombres de las carpetas. Una estructura de carpetas típica se ve así:

Conceptos Django

django-admin es una herramienta de línea de comandos que se envía con Django. Viene con varios comandos útiles para comenzar y administrar un proyecto Django. El comando es el mismo que ./manage.py , con la diferencia de que no es necesario que esté en el directorio del proyecto. La variable de entorno DJANGO_SETTINGS_MODULE debe configurarse.

Un proyecto de Django es un código base de Python que contiene un archivo de configuración de Django. El administrador de Django puede crear un proyecto mediante el comando django-admin startproject NAME . El proyecto normalmente tiene un archivo llamado manage.py en el nivel superior y un archivo URL raíz llamado urls.py manage.py es una versión específica del proyecto de django-admin , y le permite ejecutar comandos de administración en ese proyecto. Por ejemplo, para ejecutar su proyecto localmente, use python manage.py runserver . Un proyecto se compone de aplicaciones Django.

Una aplicación de Django es un paquete de Python que contiene un archivo de modelos ( models.py de forma predeterminada) y otros archivos, como urls y vistas específicas de la aplicación. Se puede crear una aplicación a través del comando django-admin startapp NAME (este comando debe ejecutarse desde el directorio de su proyecto). Para que una aplicación sea parte de un proyecto, debe incluirse en la lista de INSTALLED_APPS en settings.py . Si usó la configuración estándar, Django viene con varias aplicaciones de sus propias aplicaciones preinstaladas que manejarán cosas como la autenticación para usted. Las aplicaciones se pueden utilizar en múltiples proyectos de Django.

El ORM de Django recopila todos los modelos de base de datos definidos en models.py y crea tablas de base de datos basadas en esas clases de modelos. Para hacer esto, primero, configure su base de datos modificando la configuración de DATABASES en settings.py . Luego, una vez que haya definido sus modelos de base de datos , ejecute python manage.py makemigrations seguido de python manage.py migrate para crear o actualizar el esquema de su base de datos según sus modelos.

Un ejemplo completo de hola mundo.

Paso 1 Si ya tienes Django instalado, puedes omitir este paso.

pip install Django

Paso 2 Crear un nuevo proyecto

django-admin startproject hello

Eso creará una carpeta llamada hello que contendrá los siguientes archivos:

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

Paso 3 Dentro del módulo de hello (la carpeta que contiene el __init.py__ ) cree un archivo llamado views.py :

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

y poner en el siguiente contenido:

from django.http import HttpResponse

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

Esto se llama una función de vista.

Paso 4 Edita hello/urls.py como sigue:

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

que enlaza la función de vista hello() a una URL.

Paso 5 Inicia el servidor.

python manage.py runserver

Paso 6

Vaya a http://localhost:8000/ en un navegador y verá:

Hola Mundo

Ambiente virtual

Aunque no es estrictamente necesario, se recomienda iniciar su proyecto en un "entorno virtual". Un entorno virtual es un contenedor (un directorio) que contiene una versión específica de Python y un conjunto de módulos (dependencias), y que no interfiere con el Python nativo del sistema operativo u otros proyectos en la misma computadora.

Al configurar un entorno virtual diferente para cada proyecto en el que trabaja, varios proyectos de Django pueden ejecutarse en diferentes versiones de Python y pueden mantener sus propios conjuntos de dependencias, sin riesgo de conflicto.

Python 3.3+

Python 3.3+ ya incluye un módulo venv estándar, al que normalmente puedes llamar como pyvenv . En entornos donde el comando pyvenv no está disponible, puede acceder a la misma funcionalidad invocando directamente el módulo como python3 -m venv .

Para crear el entorno virtual:

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

Python 2

Si usa Python 2, primero puede instalarlo como un módulo separado de pip:

$ pip install virtualenv

Y luego cree el entorno usando el comando virtualenv lugar:

$ virtualenv <env-folder>

Activar (cualquier versión)

El entorno virtual ya está configurado. Para poder utilizarlo, debe estar activado en el terminal que desea utilizar.

Para 'activar' el entorno virtual (cualquier versión de Python)

Linux como:

$ source <env-folder>/bin/activate

Windows como:

<env-folder>\Scripts\activate.bat

Esto cambia su indicador para indicar que el entorno virtual está activo. (<env-folder>) $

De ahora en adelante, todo lo que se instale usando pip se instalará en su carpeta de env virtual, no en todo el sistema.

Para salir del entorno virtual utilice deactivate :

(<env-folder>) $ deactivate

Alternativamente: use virtualenvwrapper

También puede considerar el uso de virtualenvwrapper, que hace que la creación y activación de virtualenv sea muy útil, así como la separación de su código:

# Create a virtualenv
mkvirtualenv my_virtualenv

# Activate a virtualenv
workon my_virtualenv

# Deactivate the current virtualenv
deactivate

Alternativamente: use pyenv + pyenv-viritualenv

En entornos en los que necesita manejar varias versiones de Python, puede beneficiarse de virtualenv junto con 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

Cuando se utiliza virtualenvs, a menudo es útil configurar PYTHONPATH y DJANGO_SETTINGS_MODULE en el script 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"

Establece la ruta de tu proyecto

A menudo también es útil configurar la ruta de su proyecto dentro de un archivo .project especial ubicado en su <env-folder> . Al hacer esto, cada vez que active su entorno virtual, cambiará el directorio activo a la ruta especificada.

Cree un nuevo archivo llamado <env-folder>/.project . El contenido del archivo SOLO debe ser la ruta del directorio del proyecto.

/path/to/project/directory

Ahora, inicie su entorno virtual (ya sea utilizando source <env-folder>/bin/activate workon my_virtualenv o workon my_virtualenv ) y su terminal cambiará los directorios a /path/to/project/directory .

Un solo archivo Hello World Ejemplo

Este ejemplo muestra una forma mínima de crear una página Hello World en Django. Esto le ayudará a darse cuenta de que el comando de django-admin startproject example crea básicamente un montón de carpetas y archivos y que no necesariamente necesita esa estructura para ejecutar su proyecto.

1. Crea un archivo llamado file.py

2. Copia y pega el siguiente código en ese archivo.

    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. Vaya a la terminal y ejecute el archivo con este comando python file.py runserver .

4. Abra su navegador y vaya a 127.0.0.1:8000 .

Proyecto de implementación amigable con soporte Docker.

La plantilla de proyecto Django predeterminada está bien, pero una vez que implementas tu código y, por ejemplo, los desarrolladores ponen sus manos en el proyecto, las cosas se complican. Lo que puede hacer es separar su código fuente del resto que se requiere para estar en su repositorio.

Puede encontrar una plantilla de proyecto Django utilizable en GitHub .

Estructura del proyecto

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

Me gusta mantener el directorio de service denominado service para cada proyecto gracias a que puedo usar el mismo Dockerfile en todos mis proyectos. La división de requisitos y configuraciones ya está bien documentada aquí:
Usando múltiples archivos de requerimientos
Usando múltiples configuraciones

Dockerfile

Con el supuesto de que solo los desarrolladores hacen uso de Docker (no todos los desarrolladores de operaciones confían en ello en estos días). Esto podría ser un entorno de desarrollo 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"]

Agregar solo los requisitos aprovechará la memoria caché de Docker mientras se construye, solo necesita reconstruir el cambio de requisitos.

Componer

Docker compose es muy útil, especialmente cuando tiene múltiples servicios para ejecutar localmente. 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

Su entorno de desarrollo debe ser lo más cercano posible al entorno prod, por lo que me gusta usar Nginx desde el principio. Aquí hay un ejemplo de archivo de configuración nginx:

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

Uso

$ 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