Comenzando con Django

Inicio de 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 si omite la versión que se muestra a continuación, se 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 se está ejecutando, visite http://127.0.0.1:8000/ con su navegador web. Verá la siguiente página:

ingrese la descripción de la imagen aquí

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.

Agregar una aplicación Django

Un proyecto de Django generalmente contiene múltiples aplicaciones. Esta es simplemente una forma de estructurar su proyecto en módulos más pequeños y fáciles de mantener. Para crear una aplicación, vaya a la carpeta de su proyecto (donde se encuentra manage.py) 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, como models.py y views.py.

Para que Django conozca myapp, agréguelo a su settings.py:

# myproject/settings.py

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

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

estructura de directorios

Ambiente virtual

Aunque no es estrictamente necesario, se recomienda encarecidamente 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 ni con 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.

Pitón 3.3+

Python 3.3+ ya incluye un módulo venv estándar, que normalmente puede llamar 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>

Pitón 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 en su lugar:

$ virtualenv <env-folder>

Activar (cualquier versión)

El entorno virtual ya está configurado. Para usarlo, debe estar activado en la terminal en la que desea usarlo.

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

Linux como:

$ source <env-folder>/bin/activate

ventanas como:

<env-folder>\Scripts\activate.bat

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

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

Para salir del entorno virtual usa deactivate :

(<env-folder>) $ deactivate

Alternativamente: use virtualenvwrapper

También puede considerar usar virtualenvwrapper, lo que hace que la creación y activación de virtualenv sea muy útil, además de separarlo 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-virtualenv

En entornos donde 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

Al usar virtualenvs, a menudo es útil configurar su PYTHONPATH y DJANGO_SETTINGS_MODULE en el postactivate script.

#!/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"

Establezca la ruta de su proyecto

A menudo, también es útil establecer la ruta de su proyecto dentro de un archivo .project especial ubicado en su base <carpeta-env>. 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, inicia tu entorno virtual (ya sea usando source <env-folder>/bin/activate o workon my_virtualenv) y tu terminal cambiará los directorios a /ruta/al/proyecto/directorio.

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 de Django. El comando es el mismo que ./manage.py, con la diferencia de que no necesita estar en el directorio del proyecto. La variable de entorno DJANGO_SETTINGS_MODULE debe configurarse.

Un proyecto 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 de URL raíz llamado urls.py. manage.py es una versión específica de 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 por defecto) y otros archivos, como direcciones URL y vistas específicas de la aplicación. Se puede crear una aplicación mediante el 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 estar incluida en la lista INSTALLED_APPS en settings.py. Si usó la configuración estándar, Django viene con varias aplicaciones propias preinstaladas que manejarán cosas como autenticación por usted. Las aplicaciones se pueden usar en múltiples proyectos de Django.

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

[6]: https://docs.djangoproject.com/en/stable/ref/settings/#bases de datos [7]: https://docs.djangoproject.com/en/stable/topics/db/models/ [8]: https://docs.djangoproject.com/en/stable/ref/django-admin/#makemigrations [9]: https://docs.djangoproject.com/en/stable/ref/django-admin/#migrate

Ejemplo de Hello World de archivo único

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

  1. Cree un archivo llamado file.py.

  2. Copie y pegue 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.

Un ejemplo completo de hola mundo.

Paso 1 Si ya tiene instalado Django, puede omitir este paso.

pip install Django

Paso 2 Crear un nuevo proyecto

django-admin startproject hello

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

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

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

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

y poner 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 Edite hello/urls.py de la siguiente manera:

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 vincula la función de visualización hola() a una URL.

Paso 5 Inicie el servidor.

python manage.py runserver

Paso 6

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

Hola mundo

Proyecto fácil de implementar con soporte Docker.

La plantilla de proyecto Django predeterminada está bien, pero una vez que implementa su 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 que esté 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 servicio llamado servicio 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í: https://www.wikiod.com/es/django/ajustes#Uso de varios archivos de requisitos https://www.wikiod.com/es/django/ajustes#Uso de múltiples configuraciones

Dockerfile

Con la suposición de que solo los desarrolladores hacen uso de Docker (no todas las operaciones de desarrollo confían en él en estos días). Este 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 requisitos aprovechará la memoria caché de Docker durante la compilación: solo necesita reconstruir cuando cambien los requisitos.

Componer

Docker compose es útil, especialmente cuando tiene varios 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 estar lo más cerca posible del entorno de producción, por lo que me gusta usar Nginx desde el principio. Aquí hay un archivo de configuración de nginx de ejemplo:

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