Hogar › Servicios › Creando nuestra primera aplicación web usando Django. Implementamos una aplicación Django en producción usando el ejemplo de un bot de Telegram. Instalación global de Django desde un paquete

Creando nuestra primera aplicación web usando Django. Implementamos una aplicación Django en producción usando el ejemplo de un bot de Telegram. Instalación global de Django desde un paquete

Esta nota es una continuación del artículo sobre cómo escribir un bot de Telegram, en el que intentaré cubrir con el mayor detalle posible el tema de la implementación de una aplicación Django completa, aunque pequeña, en un entorno de producción en el sistema operativo Linux, Ubuntu. 14,04 litros. Al final del artículo, tendremos un bot de Telegram completo, girando en la web y recibiendo comandos de los usuarios de este mensajero.

Lo que aprenderás después de leer la nota:

Implemente una aplicación Django (o cualquier aplicación WSGI) en el hosting de Digital Ocean entorno linux
Trabajar con servidores web nginx y gunicorn
Gestione procesos utilizando la utilidad de supervisión
Configurar virtualenv usando pyenv
Iniciar automáticamente la aplicación web incluso después de reiniciar el servidor

En septiembre de 2015, celebramos una reunión de Python en Almaty, donde hablé con . Durante la charla, describí brevemente el ecosistema web Python y ofrecí una breve descripción de las herramientas populares. Desafortunadamente, el formato de la reunión no proporcionó un análisis detallado del tema, por lo que los recién llegados a esta área generalmente tienen que investigar más por su cuenta. Hoy intentaré llenar este vacío y profundizar un poco más en el tema "candente" de la implementación de aplicaciones web en Python. A pesar de que el artículo se centrará en una aplicación Django, las recetas descritas también serán relevantes para otros proyectos web desarrollados en Python utilizando marcos compatibles con WSGI (Flask, Bottle, Pyramid, Falcon, web2py, etc.).

En esta nota me desplegaré a alojamiento virtual por Océano Digital. Si se registra usando este enlace, luego de confirmar sus detalles de pago, su cuenta se recargará inmediatamente con $10, que puede gastar en la creación de pequeños droplets (servidores virtuales) y practicar la implementación de proyectos web en Python. Diré de inmediato que no es necesario hacer todo en una máquina remota y, en general, utilizar un proveedor de alojamiento; puede arreglárselas con una máquina virtual local, por ejemplo, usando VirtualBox (pero en este caso será imposible; para instalar un webhook).

Creando un servidor virtual

Como mencioné anteriormente, realizaremos la implementación en uno de los servidores virtuales de DigitalOcean con su potente API :)

Cree una gota haciendo clic en "Crear gota" en la esquina superior derecha del panel de control:

Elegimos la tarifa mínima por 5 dólares al mes con el sistema operativo Ubuntu 14.04.4 LTS a bordo de la futura máquina virtual.

Casi siempre elijo Frankfurt como centro de datos porque tengo el mejor ping. Después de completar todos los campos obligatorios, haga clic en el botón "Crear". El droplet se crea en 60 segundos, después de lo cual se envía a su correo electrónico toda la información sobre la nueva máquina virtual necesaria para acceder: dirección IP, nombre de usuario y contraseña.

Configuración del servidor

Actualización de paquetes:

# apt-get actualización # apt-get -y actualización

# adduser django # adduser django sudo

Iniciar sesión con un nuevo usuario Django al servidor, y todos los demás comandos se ejecutan desde este usuario.
Instalamos el arsenal necesario para configurar un entorno virtual a través de Pyenv y montar lo último Versiones de Python (2.7.11).

$ sudo apt-get install -y build-essential $ sudo apt-get install -y python-dev libreadline-dev libbz2-dev libssl-dev libsqlite3-dev libxslt1-dev libxml2-dev $ sudo apt-get install -y git

Después de eso instalamos el propio Pyenv. Puedes leer más sobre qué es Pyenv y cómo configurarlo:
Instale la última versión de Python (Python 2.7.11):

$ pyenv install 2.7.11 Descargando Python-2.7.11.tgz... -> https://www.python.org/ftp/python/2.7.11/Python-2.7.11.tgz Instalando Python-2.7.11 ... Instalé Python-2.7.11 en /home/django/.pyenv/versions/2.7.11

El comando tardará algún tiempo en completarse (el script descargará Python y lo compilará desde el código fuente). Al instalar un intérprete de Python por separado, no afectamos de ninguna manera el funcionamiento del sistema; además, en la última versión de LTS Versiones de ubuntu(14.04) se utiliza la versión 2.7.6, que tiene una serie de vulnerabilidades graves, incluido un error con SSL, y también carece de soporte para TLS 1.2

Clonamos el repositorio con el proyecto Django:

$ cd ~ $ git clon https://github.com/adilkhash/planetpython_telegrambot.git $ cd planetpython_telegrambot/

$ pyenv virtualenv 2.7.11 telegram_bot $ pyenv telegram_bot local

Instalamos dependencias usando el administrador de paquetes pip.

Instalación de pip -r requisitos.txt

La aplicación Django escrita en la primera parte ha sufrido cambios menores. En particular, transfirí las partes modificables del código a un archivo .env especial usando la biblioteca django-environ. Puedes ver los cambios usando este enlace.

Cree un archivo .env a partir de la plantilla y complete la configuración necesaria.

$ cd blog_telegram && mv .env-template .env && vi .env

En particular, debe cambiar el modo DEBUG a Falso, registrar un token para el bot de Telegram y especificar un host adicional separado por comas en ALLOWED_HOSTS. En mi caso, ALLOWED_HOSTS se ve así:

ALLOWED_HOSTS=127.0.0.1,sitio.bot

Es decir, creé un subdominio adicional en el que se ejecutará el bot de Telegram.

Configurar un certificado SSL

En el artículo anterior, escribí que cuando se utiliza la llamada API setWehook, el host debe tener un certificado SSL válido (Telegram también permite el uso de certificados autofirmados). Crearemos el certificado a través del servicio gratuito de emisión de certificados SSL Let's Encrypt.

$ cd ~ && git clone https://github.com/letsencrypt/letsencrypt $ cd letsencrypt/ $ ./letsencrypt-auto certonly --standalone -d bot.site

Deberá especificar algunas configuraciones y aceptar los términos de servicio. Después de la ejecución exitosa de los comandos, los certificados se ubicarán en /etc/letsencrypt/live/bot.site/

Configurando Nginx

Ahora es el momento de instalar el popular servidor HTTP nginx, que en nuestro caso actuará como proxy (recibirá solicitudes de los clientes y las reenviará siguiendo las instrucciones del archivo de configuración).

$ sudo apt-get install -y nginx $ cd /etc/nginx/sites-available/ $ sudo nano telegram_bot.conf

Complete el nuevo archivo telegram_bot.conf con el siguiente contenido:

Servidor ( escucha 80; escucha 443 ssl; nombre_servidor bot..site/fullchain.pem; clave_certificado_ssl /etc/letsencrypt/live/bot..pem; ubicación / ( proxy_set_header Host $http_host; proxy_redirect desactivado; proxy_set_header X-Forwarded-For $ proxy_add_x_forwarded_for; proxy_set_header X-Real-IP $remote_addr; proxy_set_header proxy_pass http://localhost:8001/);

ADVERTENCIA: No olvides reemplazar el host sitio.bot por tu cuenta.

Registramos nuestra nueva configuración en configuración de nginx y reinícialo para que los cambios surtan efecto:

$ cd /etc/nginx/sites-enabled/ $ sudo ln -s ../sites-available/telegram_bot.conf telegram_bot.conf $ sudo service nginx restart

¿Qué acabamos de hacer?

Hemos registrado un certificado SSL válido para nuestro sitio web.
Todas las solicitudes que lleguen al host se enviarán a nuestra futura aplicación Django, que a su vez debería ejecutarse en el puerto 8001.
Transmitimos encabezados HTTP adicionales en cada solicitud (host, dirección IP del cliente, esquema https/http, etc.). Puede leer más sobre la configuración de nginx.

Para verificar el éxito de nuestra configuración, podemos ejecutar la aplicación Django a través de servidor de prueba comando runserver en el puerto 8001 y vaya al sitio:

$ cd ~/planetpython_telegrambot/ $ python Manage.py RunServer 8001

Abra el navegador y vea (lo abrí inmediatamente a través de https):

URL Extraviado Este es un fenómeno normal, ya que solo tenemos 1 URL válida para trabajar directamente con Telegram: /planet/bot// (sin contar la configuración de administrador de Django).

Configurando Gunicorn a través del Supervisor

Es hora de comenzar a configurarlo listo para producción. Servidores HTTP gunicornio, que, por cierto, está escrito íntegramente en lenguaje pitón y ha demostrado su eficacia en combate real (por cierto, en todos los proyectos "en vivo" uso esta combinación particular: nginx+gunicorn)

¿Qué es la supervisora?

Supervisor Esta es una utilidad de gestión de procesos. "Monitorea la salud" de los procesos de tu demonio y, si fallan, intenta reactivarlos nuevamente. Si Gunicorn “cae” durante la operación (error del sistema, fase lunar incorrecta, etc.), Supervisor intenta “levantarlo” nuevamente, para que el rendimiento del sitio no se vea afectado. Por cierto, tengo planes de escribir una breve nota sobre esta utilidad, por así decirlo, Supervisor Advanced Usage. Vale la pena señalar que todos los procesos que se ejecutan en Supervisor deben ejecutarse en modo de primer plano para que la utilidad entienda cuando algo no va según lo planeado.

Primero, creemos un archivo de configuración para ejecutar Gunicorn dentro de Supervisor. Su contenido se ve así:

Command=/home/django/.pyenv/versions/telegram_bot/bin/gunicorn blog_telegram.wsgi:application -b 127.0.0.1:8001 -w 1 --timeout=60 --graceful-timeout=60 --max-requests= 1024 directorio=/home/django/planetpython_telegrambot/ user=django redirección_stderr=True stdout_logfile=/tmp/gunicorn.log stderr_logfile=/tmp/gunicorn_err.log autostart=true autoresart=true startecs=10 stopwaitsecs=10 prioridad=999

Guarde el archivo con el nombre gunicorn.conf ( ~/planetpython_telegrambot/gunicorn.conf). Por cierto, Gunicorn está incluido en las dependencias de nuestro proyecto ( requisitos.txt) y como ya lo hemos instalado en nuestro entorno, entonces averigüe la ruta archivo ejecutable puede ejecutar el comando dentro del entorno virtual activado (la activación se produce automáticamente cuando va al directorio de la aplicación web debido a la presencia de un archivo allí .python-versión creado a través de pyev local):

$pyenv cual gunicornio

Contenido del archivo de configuración para supervisord:

File=/tmp/telgram_bot_supervisord.sock logfile=/tmp/telgram_bot_supervisord.log logfile_maxbytes=50MB logfile_backups=10 loglevel=info pidfile=/tmp/telgram_bot_supervisord.pid nodaemon=false minfds=1024 minprocs=200 supervisor.rpcinterface_factory = interfaz supervisor.rpc : make_main_rpcinterface serverurl=unix:///tmp/telgram_bot_supervisord.sock files = /home/django/planetpython_telegrambot/gunicorn.conf

Guardar en ~/planetpython_telegrambot/supervisord.conf

$superd

El lanzamiento debería realizarse sin errores. Para conocer el estado de los procesos actuales, ejecute la utilidad supervisorctl:

$ supervisorctl gunicorn EJECUTANDO pid 20901, tiempo de actividad 0:04:18 supervisor>

Para obtener ayuda, puede ejecutar el comando de ayuda. Y para obtener información sobre el comando ayuda. Por ejemplo:

Supervisor> ayuda detener detener Detener un proceso detener:* Detener todos los procesos en un grupo detener Detener múltiples procesos o grupos detener todos Detener todos los procesos supervisor>

Después de iniciar con éxito el supervisor, el sitio debería estar disponible en línea.

Aplicación web de inicio automático al reiniciar

¿Qué pasará si nuestro servidor virtual reiniciar de repente? (una falla en el centro de datos, problemas en la máquina host, un administrador corrupto que se equivocó, etc.). En caso de tal escenario, ahora nuestra aplicación no se iniciará automáticamente. Para solucionar este problema, debemos esforzarnos un poco más en escribir un pequeño script, que colocaremos con éxito en el mecanismo de inicio del sistema operativo Ubuntu (distribuciones similares a Debian).

¿Alguna vez has oído hablar de los llamados archivos advenedizos? Es la escritura de uno de ellos lo que vamos a hacer ahora. Por cierto, en momento actual Upstart ha sido declarado obsoleto y está prevista una transición completa a systemd en las nuevas versiones del sistema operativo basado en Linux.

Descripción "Controlador de inicio de la aplicación Django del bot Supervisor Telegram" iniciar en el nivel de ejecución detener en el nivel de ejecución [!2345] reaparecer setuid django setgid django chdir /home/django/planetpython_telegrambot/ exec /home/django/.pyenv/versions/telegram_bot/bin/supervisord

El archivo debe colocarse en /etc/inicio/(en mi caso le puse el nombre telegram_bot.conf). Si anteriormente todos los lanzamientos no causaron problemas, luego de reiniciar el sistema, la aplicación se iniciará automáticamente:

$ sudo apagado -r ahora

Ahora necesitamos registrar nuestra URL en el lado de Telegram usando la llamada API setWebhook:

Importar telepot bot_token = "BOT_TOKEN" bot = telepot.Bot(bot_token) bot.setWebhook("https://bot..format(bot_token=bot_token))

Esto completa la configuración del bot. Enviamos comandos a nuestro bot @PythonPlanetBot y recibimos respuestas adecuadas :)

registrar solicitudes de usuarios en un archivo
llevado a cabo configuraciones cambiables(modo de depuración, token de bot, clave secreta) a variables de entorno a través de archivos .env usando django-environ
plantillas agregadas archivos de configuración para gunicorn, nginx y supervisor

Sé que realmente no hay uno la manera correcta. Sin embargo, me ha resultado difícil crear una estructura de directorios que funcione bien y se mantenga limpia para todos los desarrolladores y administradores. La mayoría de los proyectos en github tienen una estructura estándar. Pero no muestra una manera de organizar otros archivos y todos los proyectos en la PC.

cual es el mejor manera conveniente¿Organizar todos estos directorios en la máquina de desarrollo? ¿Cómo se llaman y cómo se conectan e implementan en el servidor?

proyectos (todos los proyectos en los que estás trabajando)
archivos fuente (la aplicación en sí)
copia de trabajo del repositorio (yo uso git)
entorno virtual (prefiero colocarlo al lado del proyecto)
raíz estática (para archivos estáticos compilados)
raíz multimedia (para archivos multimedia descargados)
LÉAME
LICENCIAS
documentos
bocetos
(proyecto de ejemplo que utiliza la aplicación proporcionada por este proyecto)
(en caso de usar sqlite)
todo lo que normalmente necesitas para trabajar con éxito en un proyecto

Problemas que quiero resolver:

4 respuestas

Hay dos tipos de proyectos Django que tengo en mi directorio ~/projects/, ambos tienen una estructura ligeramente diferente:

Sitios sin conexión
Aplicaciones conectadas

Sitio web sin conexión

La mayoría de las veces son proyectos privados, pero no necesariamente. Suele tener este aspecto:

~/projects/project_name/ docs/ # scripts de documentación/manage.py # instalado en PATH a través de setup.py nombre_proyecto/ # directorio del proyecto (el que crea django-admin.py) apps/ # cuentas de aplicaciones específicas del proyecto/ # most aplicación frecuente, con modelo de usuario personalizado __init__.py ... settings/ # configuraciones para diferentes entornos, ver más abajo __init__.py production.py development.py ... __init__.py # contiene la versión del proyecto urls.py wsgi.py static/ # plantillas de archivos estáticos específicos del sitio/ # pruebas de plantillas específicas del sitio/ # pruebas específicas del sitio (principalmente en el navegador) tmp/ # excluidos de git setup.py requisitos.txt requisitos_dev.txt pytest.ini...

Ajustes

Los escenarios principales son los de producción. Otros archivos (por ejemplo, staging.py, development.py) simplemente importan todo desde production.py y anulan sólo las variables necesarias.

Para cada entorno existen archivos separados ajustes, por ejemplo. producción, desarrollo. Tengo algunos proyectos que he probado (para probador), (como verificación antes de la implementación final) y heroku (para implementación en heroku).

Requisitos

Prefiero establecer los requisitos directamente en setup.py. Solo los necesarios para el entorno de desarrollo/prueba los tengo requerimientos_dev.txt.

Algunos servicios (por ejemplo, heroku) requieren requisitos.txt en el directorio raíz.

configuración.py

Útil al implementar un proyecto usando herramientas de configuración. Agrega Manage.py a PATH para que pueda ejecutar Manage.py directamente (en cualquier lugar).

Aplicaciones para proyectos específicos.

Utilicé estas aplicaciones en el directorio nombre_proyecto/apps/ y las importé mediante importación relativa.

Plantillas/archivos estáticos/locales/de prueba

Coloqué estas plantillas y archivos estáticos en plantillas globales/directorio estático en lugar de dentro de cada aplicación. Estos archivos generalmente son editados por personas que no necesitan el marco o el código del proyecto Python en absoluto. Si es un desarrollador completo que trabaja solo o en un equipo pequeño, puede crear plantillas por aplicación/directorio estático. Realmente es sólo una cuestión de gustos.

Lo mismo se aplica al idioma, aunque a veces es conveniente crear un directorio local separado.

Las pruebas generalmente se ubican mejor dentro de cada aplicación, pero generalmente hay muchas pruebas de integración/funcionales que prueban más aplicaciones trabajando juntas, por lo que tiene sentido un directorio de pruebas global.

directorio tmp

Hay un directorio temporal en la raíz del proyecto que está excluido de VCS. Solía almacenar archivos multimedia/estáticos y una base de datos sqlite durante el desarrollo. Todo lo que hay en tmp se puede eliminar en cualquier momento sin ningún problema.

entorno virtual

Prefiero virtualenvwrapper y pongo todos los venvs en el directorio ~/.venvs pero puedes colocarlos dentro de tmp/ para mantenerlos juntos.

plantilla de proyecto

Creé una plantilla de proyecto para esta instalación, django-start-template

Despliegue

Este proyecto se implementa de la siguiente manera:

Fuente $VENV/bin/activate export DJANGO_SETTINGS_MODULE=nombre_proyecto.settings.production git pull pip install -r requisitos.txt # Actualizar base de datos, archivos estáticos, configuraciones regionales administrar.py syncdb --noinput administrar.py migrar administrar.py recolectar estática --noinput administrar.py makemessages -a administrar.py compilar mensajes # reiniciar wsgi touch nombre_proyecto/wsgi.py

Puedes usar rsync en lugar de git, pero aún necesitas ejecutar un lote de comandos para actualizar tu entorno.

Recientemente creé una aplicación que me permite ejecutar un único comando de control para actualizar el entorno, pero solo la he usado para un proyecto y todavía estoy experimentando con ella.

Bocetos y borradores.

Un borrador de las plantillas que coloco dentro del directorio global templates/. Creo que es posible crear una carpeta de bocetos/en la raíz del proyecto, pero aún no la he usado.

Aplicación conectada

Estas aplicaciones suelen estar preparadas para su publicación como código abierto. He proporcionado un ejemplo a continuación django-forme

~/projects/django-app/ docs/ app/ tests/ example_project/ LICENSE MANIFEST.in README.md setup.py pytest.ini tox.ini .travis.yml ...

Los nombres de los catálogos son claros (espero). Coloqué los archivos de prueba fuera del directorio de la aplicación, pero realmente no importa. Es importante proporcionar un archivo README y setup.py para que el paquete se pueda instalar fácilmente mediante pip.

Mi respuesta está basada en mi propia experiencia laboral y principalmente en el libro Two Matching Django, que recomiendo mucho y donde puedes encontrar más. explicación detallada fuera de todo. Solo responderé algunas preguntas y cualquier mejora o corrección será bienvenida. Pero puede haber mejores resultados para lograr el mismo objetivo.

Proyectos
Tengo una carpeta principal en mi directorio personal donde veo todos los elementos en los que estoy trabajando.

Archivos fuente
Yo personalmente uso la raíz del proyecto Django como raíz del repositorio de mis proyectos. Pero el libro recomienda separar ambas cosas. Creo que este es el mejor enfoque, así que espero cambiar gradualmente mis proyectos.

Carpeta_repositorio_proyecto/ .gitignore Makefile LICENCIA.primeros documentos/ README.primeros requisitos.txt carpeta_proyecto/ administrar.py media/ app-1/ app-2/ ... app-n/ static/ templates/ project/ __init__.py settings/ __init__ .py base.py dev.py local.py prueba.py producción.py ulrs.py wsgi.py

Repositorio
Git o Mercurial parecen ser los más sistemas populares Control de versiones entre desarrolladores de Django. Y los servicios de alojamiento de respaldo más populares son GitHub y Bitbucket.

Entorno virtual
Estoy usando virtualenv y virtualenvwrapper. Después de instalar el segundo, debe configurar el directorio de trabajo. El mío está ubicado en el directorio my/home/envs, como se recomienda en la guía de instalación de virtualenvwrapper. Pero no creo que lo más importante sea dónde se coloca. Lo más importante al trabajar con entornos virtuales- actualice el archivo requisitos.txt.

Congelación de pip -l > requisitos.txt

raíz estática
Carpeta de proyecto

Medios raíz
Carpeta de proyecto

LÉAME
Raíz del repositorio

LICENCIA
Raíz del repositorio

Documentos
Raíz del repositorio. Estos paquetes de Python puede ayudarle a simplificar su documentación:

Bocetos

Ejemplos

Base de datos

no me gusta crear nuevo catalogo ajustes/ . Solo estoy agregando archivos llamados settings_dev.py y settings_production.py para no tener que editar BASE_DIR. El siguiente enfoque aumenta la estructura predeterminada en lugar de cambiarla.

Mysite/ # Project conf/ locale/ en_US/ fr_FR/ it_IT/ mysite/ __init__.py settings.py settings_dev.py settings_production.py urls.py wsgi.py static/ admin/ css/ # Estilos de back-end personalizados css/ # Frontal del proyecto estilos finales fuentes/ imágenes/ js/ sass/ archivos estáticos/ plantillas/ # Las plantillas del proyecto incluyen/ footer.html header.html index.html myapp/ # Núcleo de la aplicación/ migraciones/ __init__.py templates/ # Plantillas de la aplicación myapp/ index.html estática / myapp/ js/ css/ images/ __init__.py admin.py apps.py form.py models.py models_foo.py models_bar.py views.py templatetags/ # Aplicación con procesadores de contexto personalizados y etiquetas de plantilla __init__.py context_processors.py templatetags/ __init__.py templatetag_extras.py gulpfile.js administrar.py requisitos.txt

Llevo mucho tiempo siguiendo el desarrollo del proyecto DjangoCMS y, sinceramente, no siempre me gustó. Pero gradualmente el equipo del proyecto corrigió muchos de los errores e hizo que este CMS fuera realmente conveniente, flexible y funcional. Después de eso, me volví casi un fanático de DjangoCMS y lo uso en algunos de mis proyectos (por ejemplo, este blog). Hoy te contaré en detalle qué es DjangoCMS, en qué casos conviene utilizarlo y te mostraré cómo crear un sitio web sencillo usándolo. Espero que a ti también te guste esta herramienta :)

En en este momento El principal problema de DjangoCMS es la falta de documentación adecuada. Lo primero que encontré en el sitio web oficial del proyecto fueron instrucciones sobre cómo crear un sitio web usando DjangoCMS e implementarlo en plataforma en la nube Divio Nube. De esta instrucción, por supuesto, puedes extraer una cierta cantidad información útil, pero como desarrollador, espero algo completamente diferente, especialmente porque no planeo usar Divio Cloud, pero quiero implementar una aplicación en DjangoCMS en algún lugar de mi casa. Lo más interesante es que existe documentación oficial para desarrolladores en DjangoCMS, pero encontré este enlace en el archivo README.md del repositorio del proyecto en GitHub, aunque por alguna razón no está en el sitio.

Hay una cosa por la que el equipo de Divio merece un elogio especial: el soporte competente en el chat en línea del sitio web del proyecto DjangoCMS, donde puede hacer preguntas de cualquier complejidad. Aprendí muchas cosas que no se mencionan en la documentación personalmente de los chicos de Divio durante la correspondencia con ellos. También están nuestros compatriotas que respondieron en ruso, por lo que les tenemos un respeto especial :)

¡Basta de letras, comencemos a crear nuestro propio sitio web en DjangoCMS!

Instalación de DjangoCMS

Primero, necesitamos crear y activar un entorno virtual para nuestro proyecto. Para hacer esto, ejecute el comando:

Fuente de entorno virtualenv env/bin/activate

Si desea utilizar Python 3 en su proyecto, entonces el primer comando debe reemplazarse con:

Virtualenv --python=/usr/bin/python3.5 entorno

Sólo asegúrese de verificar que la ruta a su intérprete de Python 3 sea correcta, ya que la suya puede diferir.

Una vez creado y activado el entorno virtual, necesitamos instalar el instalador de DjangoCMS: el paquete djangocms-installer:

Pip instala el instalador de djangocms

djangocms-installer instala todo paquetes requeridos para que DjangoCMS funcione. Después de esto, su entorno virtual comienza a admitir el comando djangocms, que usaremos en breve.

Creemos un directorio para nuestro proyecto y vayamos a él:

mkdir django_cms_project cd django_cms_project

Y finalmente creamos nuestra aplicación en DjangoCMS usando el comando:

Djangocms-f-p. django_cms_ejemplo

El indicador -f indica que se instalará adicionalmente la herramienta Django Filer, que es responsable de trabajar con el sistema de archivos. A mí esta herramienta Me gusta y recomiendo usarlo.
El indicador -p seguido de un punto (-p . ) establece el directorio actual como el directorio principal del proyecto.
djangocms_blog es el nombre de nuestra aplicación. Puedes especificar el tuyo propio.

En versiones anteriores, el instalador de DjangoCMS hacía preguntas para configurar la aplicación durante la instalación. En la nueva versión, la aplicación se configura automáticamente y se crea un superusuario con el inicio de sesión de administrador y la contraseña de administrador. Después de la instalación, puede ejecutar la aplicación con el comando:

Servidor de ejecución Python Manage.py

Después de ejecutar el comando, abra el enlace http://127.0.0.1:8000/ en su navegador. Si lo haces correctamente, deberías ver un formulario de inicio de sesión en tu panel de administración de Django:

Para iniciar sesión, simplemente ingrese el nombre de usuario admin y la contraseña admin. Esto completa el proceso de instalación de DjangoCMS.

Ajustes

Abra el proyecto recién creado en su IDE favorito (personalmente prefiero PyCharm). En mi caso, los archivos del proyecto se encuentran en el directorio djangocms_blog_project. La estructura del proyecto creado debería ser algo como esto:

Como puede ver, este es un proyecto de Django normal, solo que con DjangoCMS instalado en la configuración (archivo settings.py). En general, nuestro proyecto arranca y funciona bien, pero debes recordar que se utilizará el valor predeterminado. datos SQLite, que es bueno para depurar, pero nada adecuado para trabajar en condiciones reales. Además, DjangoCMS almacena mucha información en la base de datos: contenido, menú, lista de páginas, configuración de cada página, publicaciones, etc. Es decir, al pasar a otra base de datos, tendrás que hacer una migración, y recomiendo usar inmediatamente la base de datos cuyo volcado luego se puede transferir a producción. Pero esto es sólo una recomendación; puede depurar con éxito la aplicación utilizando SQLite e información falsa en las páginas, y luego crear una versión limpia sobre una nueva base utilizando las plantillas depuradas. O, como señaló correctamente Dmytro Kyrychuk en los comentarios, use los comandos Manage.py dumpdata y loaddata (estos comandos se describen en detalle aquí: https://docs.djangoproject.com/en/1.10/ref/django-admin/ ) para volcar una base de datos en JSON y restaurar el volcado en otra base de datos.

Como mi proyecto es una demostración, dejo la configuración de la base de datos sin cambios:

BASES DE DATOS = ( "predeterminado": ( "CONN_MAX_AGE": 0, "ENGINE": "django.db.backends.sqlite3", "HOST": "localhost", "NAME": "project.db", "PASSWORD": "", "PUERTO": "", "USUARIO": "" ) )

Otras configuraciones en en esta etapa no es necesario.

Crear plantillas

Antes de crear las páginas de nuestro blog, necesitamos plantillas a partir de las cuales se crearán estas mismas páginas. Seguramente querrás utilizar tu propio diseño único para hacerlo mejor que el de tu vecino, por lo que primero debemos profundizar en el diseño. Las plantillas de DjangoCMS son archivos regulares en formato .html con algunas etiquetas de plantilla Django y DjangoCMS. Al crear un nuevo proyecto, se generan automáticamente 4 plantillas en la carpeta de plantillas (en mi caso djangocms_blog_project/djangocms_blog/templates):

base.html: la plantilla base de la que se heredan todas las demás plantillas
fullwidth.html: plantilla de página de ancho completo con contenido en todo el ancho de la pantalla
sidebar_left.html - página con una barra lateral izquierda
sidebar_right.html - página con una barra lateral derecha

Además, la lista de plantillas debe especificarse en settings.py en la variable CMS_TEMPLATES para que pueda seleccionar la plantilla deseada en la interfaz al crear una nueva página del sitio. Por defecto tenemos configuradas 3 plantillas (todas excepto base.html):

CMS_TEMPLATES = (## Personalizar esto ("fullwidth.html", "Fullwidth"), ("sidebar_left.html", "Sidebar Left"), ("sidebar_right.html", "Sidebar Right"))

Aquí todo es simple: debe configurar el nombre real del archivo de plantilla y un nombre arbitrario que se mostrará en la interfaz. Si estas creando nueva plantilla, luego asegúrese de agregarlo a CMS_TEMPLATES; de lo contrario, no podrá usarlo.

Creemos la primera página usando las plantillas que ya tenemos. Después de haber iniciado sesión en el panel de administración con el inicio de sesión de administrador (ver arriba), debería ver esta página:

Seleccione un artículo Nueva página (Crear una página junto a la actual) y presione Próximo. Se abrirá la siguiente ventana:

Complete el título ( Hogar), ruta a la página ( índice) y contenidos ( ¡Hola Mundo!), y luego haga clic en el botón Crear. ¡Todo! Página lista:

Ahora en menú superior seleccionar Página > Plantillas:

La plantilla de página actual debe resaltarse en negrita en el menú desplegable, pero como no la configuramos explícitamente, el valor predeterminado es Heredar plantilla del ancestro más cercano. En nuestro caso, el antepasado más cercano es la plantilla fullwidth.html. Selecciónalo y verás que nada ha cambiado en el diseño de la página.

Ahora propongo analizar en detalle el código de la plantilla fullwidth.html, pero como se hereda de base.html, comencemos con plantilla base:

(% título del bloque %)Este es mi nuevo proyecto pagina de inicio(% título del bloque final%). nav (relleno-izquierda: 0;) .nav li (pantalla: en línea; tipo de estilo de lista: ninguno; relleno-derecha: 20px;) .content (flotante: izquierda; ancho). : 80%; ) .sidebar ( float: izquierda; ancho: 20%; ) (% render_block "css" %) (% cms_toolbar %) (% render_block "js" %)

¿Qué está pasando aquí? Nada especial. En la primera línea cargamos las etiquetas de la plantilla:

cms_tags: etiquetas DjangoCMS (http://docs.django-cms.org/en/release-3.4.x/reference/templatetags.html)
menu_tags: etiquetas para gestionar menús (http://docs.django-cms.org/en/release-3.4.x/reference/navigation.html)
sekizai_tags - etiquetas django-sekizai (https://django-sekizai.readthedocs.io/en/latest/)

También tenemos 2 bloques en la plantilla que se pueden redefinir en plantillas secundarias: (% título del bloque%) y (% contenido del bloque%).

Además tenemos:

etiqueta responsable de mostrar la barra de herramientas de DjangoCMS - (% cms_toolbar%)
Etiquetas django-sekizai, que son responsables de colocar bloques con enlaces a css y js en ciertas partes de la página - (% render_block "css" %) y (% render_block "js" %)
etiqueta responsable de mostrar el menú - (% show_menu 0100100 100%)

Ya sabes todo lo demás. Vayamos a la plantilla fullwidth.html:

(% extiende "base.html" %) (% carga cms_tags %) (% título del bloque %)(% page_attribute "page_title" %)(% título del bloque final %) (% contenido del bloque %) (% marcador de posición " contenido" %} {% endblock content %} !}

De hecho, tenemos una plantilla Django estándar heredada de base.html. Entre las cosas interesantes aquí hay 2 etiquetas DjangoCMS:

etiqueta (% page_attribute "page_title" %): muestra el atributo de página page_title en el bloque de título. Este atributo se establece al crear una página y es su título. Todos los atributos se pueden ver en la documentación.
etiqueta (% marcador de posición "contenido" %} - это очень !} etiqueta importante, que especifica la parte de la página que se cambiará en el bloque de contenido. El número de marcadores de posición en una página puede ser ilimitado, lo principal es que el nombre de cada marcador de posición sea único. En el panel de administración de DjangoCMS, puedes cambiar el contenido de cualquier marcador de posición a tu discreción, por ejemplo, puedes agregar texto, un enlace, una imagen, etc., o puedes hacer todo a la vez y en cualquier combinación :)

Ahora ya tienes una idea sobre las plantillas de DjangoCMS. Cambiaré y modificaré por completo las plantillas anteriores porque quiero que el sitio tenga un diseño hermoso. Todo esto es muy sencillo de implementar, pero antes de cambiar las plantillas, echemos un vistazo al panel de administración de DjangoCMS para comprender mejor los marcadores de posición. Haga clic en el botón Estructura en el panel superior y verá una página como esta:

Contenido- este es nuestro marcador de posición de contenido de la plantilla fullwidth.html. Contiene un único complemento que muestra la línea ¡Hola Mundo!. Puedes editar el contenido del complemento en cualquier momento, así como agregar otros complementos al marcador de posición e incluso crear tus propios complementos (hablaré de esto en otro artículo).

Para mayor claridad, agreguemos otro complemento al marcador de posición de contenido. Para hacer esto, haga clic en el botón + y en la ventana que aparece, seleccione un complemento de la lista mapa de google:

En la ventana que se abre, ingrese el nombre de la tarjeta (campo TÍTULO DEL MAPA), así como la latitud y longitud de su ciudad (campo LATITUD Y LONGITUD). solo tengo la palabra como titulo Mapa, latitud 55.751244 , longitud 37.618423 :

Ha aparecido un botón azul en el panel superior. Publicar cambios de página. Haga clic en él y verá la página principal actualizada con un mapa:

Así es como puedes administrar fácil y simplemente el contenido de la página en DjangoCMS.

Ahora te mostraré cómo cambiar radicalmente el diseño de tu sitio web. Lo que más me gusta de DjangoCMS es que puedes tomar casi cualquier plantilla HTML e integrarla en tu proyecto con cambios mínimos. Como ejemplo, encontré una plantilla responsiva gratuita en Internet, diseñada utilizando el marco CSS Bootstrap.

Primero, cambiemos el contenido de la plantilla base base.html:

(% carga cms_tags menu_tags sekizai_tags %) (% render_block "css" %) (% cms_toolbar %) Menú Menú Alexéi Kutepov

(% encabezado de bloque %) (% marcador de posición "título" %} {% placeholder "subtitular" %} {% endblock header %} {% block content %}{% endblock content %} !}

(% render_block "js" %)

No analizaré este código en detalle, ya que el artículo trata sobre DjangoCMS y no sobre el diseño. Además, puedes utilizar cualquier otra plantilla o crear la tuya propia. Tomé esta plantilla "tal cual" y la complementé con etiquetas Django y DjangoCMS, de las que hablaremos ahora.

Como siempre, al principio debemos cargar todas las etiquetas de plantilla necesarias:

(% carga cms_tags menu_tags sekizai_tags %)

(% título del bloque %) Sitio web de Alexey Kutepov (% título del bloque final %)

(% render_block "css" %)

Preste atención a la variable (( STATIC_URL )): Django la reemplaza automáticamente con la ruta a la carpeta con estática. También hay una etiqueta (% render_block "css" %) al final, que es inútil en esta etapa, pero puede ser de gran ayuda cuando la plantilla se vuelve más compleja: en lugar de esta etiqueta, puedes sustituir dinámicamente hojas de estilo dependiendo de ciertas condiciones.

Después de la etiqueta, debes recordar poner una etiqueta de plantilla (% cms_toolbar%) ya que es la encargada de mostrar la barra de herramientas superior en el modo de edición del sitio. Como puede ver, lo usamos con bastante frecuencia y sin él simplemente no podremos realizar cambios.

Menú Menú Alexéi Kutepov

La plantilla incluye un hermoso encabezado con una imagen de fondo. Adjunté el código responsable de mostrar el encabezado en el bloque de encabezado para que pueda redefinirse en las plantillas secundarias. Además, en el encabezado tenemos un título y un subtítulo, en lugar de los cuales agregué marcadores de posición de título y sub_título para que se puedan cambiar dinámicamente. Al cargar imagen de fondo La variable (( STATIC_URL )) es obligatoria:

(% encabezado de bloque %) (% marcador de posición "título" %} {% placeholder "subtitular" %} {% endblock header %} !}

Después del encabezado viene el bloque de contenido, con el que ya estás familiarizado gracias a la plantilla anterior:

(% contenido del bloque %)(% contenido del bloque final %)

El siguiente es el pie de página, en el que utilicé una nueva etiqueta de plantilla: . La principal diferencia entre la etiqueta static_placeholder y el marcador de posición es que las plantillas secundarias heredan el contenido de static_placeholder. EN en este caso solo necesitamos establecer el valor una vez (% static_placeholder "copyright" %} на главной странице и оно автоматически будет отображаться на других страницах нашего сайта:!}

Al final cargamos todo. guiones necesarios desde la carpeta estática:

(% render_block "js" %)

Ahora, para que la nueva plantilla se muestre correctamente, necesitas colocar todas las dependencias en la carpeta django_cms_project/django_cms_example/static/ para hacer esto, simplemente cópialas desde el repositorio de este proyecto en GitHub;

Reinicie el servidor y actualice la página en su navegador. Si hiciste todo correctamente, deberías ver el sitio con un diseño actualizado:

Aún no se muestra toda la información en la página, ya que aún no hemos completado los nuevos marcadores de posición. Haga clic en el botón azul Editar página en el panel superior y luego en el botón Estructura. Como puede ver, han aparecido 3 nuevos marcadores de posición en la estructura de la página: Título (mi sistema tradujo el nombre de este marcador de posición al ruso como Título), Sub_Título y Copyright.

Ahora necesita llenar estos marcadores de posición con cierta información, para hacer esto, haga clic en el botón + junto a cada uno de los nuevos marcadores de posición, seleccione el complemento en la ventana que se abre Texto, después de lo cual se abrirá el editor. Haga clic en el botón Fuente en la barra de herramientas del editor e ingrese cualquier texto.

Además, también tenemos un contenido de marcador de posición (Contenido), que completamos anteriormente. Quitarle el complemento mapa de google y abra el complemento para editar Texto. Luego haga clic en el botón Fuente en el editor e ingresa texto libre, encerrado en etiquetas:

texto libre

Llené los marcadores de posición así:

¡Excelente! Ahora tenemos una primera página completa del sitio. Por ejemplo, creemos una nueva plantilla y hagamos otra página. Digamos que necesitamos una plantilla especial para la sección de contactos del sitio web. Para ello, cree un archivo contacts.html en la carpeta de plantillas con el siguiente contenido:

(% extiende "base.html" %) (% carga cms_tags %) (% título de bloque %)(% page_attribute "page_title" %)(% título de bloque final %) (% encabezado de bloque %) (% marcador de posición " título" %} {% placeholder "subtitular" %} {% endblock header %} {% block content %} Контакты !}
(% marcador de posición "correo electrónico" %} !} (% marcador de posición "skype" %}!}
(% marcador de posición "teléfono" %}!}
estoy en las redes sociales
(% marcador de posición "vk" %}!}
(% marcador de posición "facebook" %}!}
(% marcador de posición "linkedin" %}!}
(% marcador de posición "github" %}!}
(% contenido del bloque final%)

No hay nada nuevo en este código, simplemente creé una lista de contactos y agregué un marcador de posición para cada contacto. También redefiní el bloque de encabezado por belleza. Ahora necesitamos agregar esta plantilla a settings.py:

CMS_TEMPLATES = (## Personalizar esto ("fullwidth.html", "Fullwidth"), ("sidebar_left.html", "Sidebar Left"), ("sidebar_right.html", "Sidebar Right"), ("contacts.html ", "Contactos"))

Ahora reinicie el servidor y cree una nueva página seleccionando en la barra superior Página > Crear página > Nueva página:

Complete todos los campos en la ventana que aparece y haga clic en el botón Guardar y continuar editando:

En la nueva ventana, haga clic en el botón Configuraciones avanzadas y seleccione la plantilla de Contactos de la lista desplegable:

Haga clic en el botón azul Ahorrar y serás redirigido automáticamente a la sección Estructura nueva pagina. Es necesario completar todos los marcadores de posición mediante complementos. Texto Y Enlace:

Campos principales:

NOMBRE PARA MOSTRAR- nombre para mostrar del enlace
ENLACE EXTERNO- se utiliza si el enlace va a un recurso externo
ENLACE INTERNO- le permite vincular a paginas internas sitio
Configuración de enlace- en esta sección nos interesan los campos que le permiten crear un enlace para correo electrónico y telefono

Como puedes ver, no hay nada complicado. El complemento es simple, fácil de usar y bastante funcional. Estoy seguro de que puedes usarlo sin ninguna dificultad.

Ahora volvamos a nuestro nueva pagina. Después de completar todos los marcadores de posición, debe hacer clic en el botón azul Publicar página inmediatamente en la barra de herramientas superior. Todos los cambios realizados en la página se guardarán, la página en sí se publicará y aparecerá en el menú principal del sitio. nuevo artículo Contactos. Esto es con lo que deberías terminar:

Tenemos un sitio pequeño y hermoso, pero como se trata de un proyecto de demostración, todavía hay mucho que se puede mejorar. Ahora conoce los conceptos básicos para trabajar con DjangoCMS y ya puede crear su propio sitio web basado en este marco.

En este artículo, mencioné solo una pequeña parte de las capacidades de DjangoCMS, por lo que a continuación hablaré sobre complementos, complementos de terceros y personalización de la funcionalidad del sitio.

Descripción del proceso de instalación rápida de Django desde el Panel de Control de Plesk.

Este artículo está desactualizado y hace referencia a un panel Plesk que ya no será compatible.

"Pro" (con acceso SSH conectado), "Plus", "VIP", así como durante el acceso de prueba a estas tarifas, y ofertas para crear rápidamente nuevo proyecto Django. Para hacer esto necesitas:

Inicie sesión en el Panel de control (recibirá las credenciales de acceso inmediatamente después).

En el menú principal del panel de control, seleccione "Dominios".

Seleccione el dominio en el que planea instalar Django.

En el grupo "Aplicaciones y servicios", seleccione "Aplicaciones web".

Ingrese django en la barra de búsqueda y luego comience la instalación.

Leer atentamente acuerdo de licencia, después del consentimiento es posible instalación adicional.

En la sección "Opciones de instalación", seleccione el directorio de destino para instalar la aplicación.

En la sección "Configuración de la base de datos", debe seleccionar el tipo (actualmente se admiten MySQL y PostgreSQL), especificar el nombre de usuario y la contraseña de la base de datos; estos parámetros se ingresarán automáticamente en el archivo settings.py.

A continuación, debe ingresar su nombre de usuario, dirección de correo electrónico y contraseña de administrador. contraseña dada se utilizará más.

La sección "Configuración personal" al instalar el paquete proporciona acceso a la configuración de Django para el nuevo proyecto, en particular:

"Nombre del proyecto Django": el nombre del proyecto Django que se creará.
“Nombre del directorio con proyectos de Django”: el nombre del directorio donde se ubicarán los proyectos de Django, este directorio estará ubicado en la carpeta privada de su sitio.
"Activar interfaz de administrador": cuando se selecciona esta opción, Django se implementa con la sección de administración habilitada, la base de datos se sincroniza, el inicio de sesión y la contraseña del administrador se establecen en los valores especificados anteriormente.
"Tu propio entorno virtual" - esta opción implica crear su propia “instancia” de Python, mientras tiene la oportunidad de instalar sus propios módulos, que pueden diferir de los instalados en el hosting cuando están habilitados, el espacio en disco ocupado por la aplicación aumenta ligeramente;

Después de la instalación esta aplicación, en http://nombre_dominio/directorio_instalación/ estará disponible la página estándar de la última instalación de Django versión estable A partir de Python 2.6.2, otras operaciones y acciones estándar, como la gestión de proyectos a través de Manage.py, requieren acceso ssh completo. Este servicio está disponible de forma predeterminada para planes tarifarios"Plus" y "VIP", en la tarifa "Pro" es posible obtener acceso ssh completo ampliando la tarifa con una opción adicional a través del sistema de facturación. Si por alguna razón este paquete no cumple con los requisitos de tu proyecto, puedes crear un proyecto Django

pip instalar Django == 2.1.7

Opción 2: obtener la versión candidata para la instalación de 2.2 pip --pre django Opción 3: obtener la última versión de desarrollo

La última y mejor versión de Django es la que está en nuestro repositorio Git (nuestro sistema de control de revisiones). Esto es sólo para usuarios experimentados que quieran probar los cambios entrantes y ayudar a identificar errores antes de un lanzamiento oficial. Consíguelo usando este comando de shell, que requiere Git:

clon de git https://github.com/django/django.git

Información adicional Para los impacientes:

Última versión:
Sumas de control:
Notas de la versión:
Versión preliminar:
Sumas de control:
Notas de la versión:

¿Qué versión es mejor?

Mejoramos Django casi todos los días y somos bastante buenos manteniendo el código estable. Por lo tanto, utilizar el código de desarrollo más reciente es una forma fácil y segura de acceder a nuevas funciones a medida que se agregan. Si elige seguir la versión de desarrollo, tenga en cuenta que ocasionalmente habrá cambios incompatibles con versiones anteriores. Querrás prestar mucha atención a las confirmaciones viendo Django en GitHub o suscribiéndote a django-updates.

Si solo está buscando un objetivo de implementación estable y no le importa esperar a la próxima versión, querrá seguir con la última versión oficial (que siempre incluirá notas detalladas sobre los cambios que deberá realizar mientras actualización).

Lanzamientos anteriores