Categorías
Python

Versiones de ejecución de Python en acoplable: Cómo probar la última Release Python

 

Tabla de Contenidos

  • Instalación Requisitos
  • configuración de actualización de
  • modelo de datos
  • local Migración
  • remoto Migración
  • Conclusión

En esta parte vamos a establecer una base de datos PostgreSQL para almacenar los resultados de nuestras cuentas de la palabra, así como SQLAlchemy, un objeto relacional Mapper, y Alambique a las migraciones de bases de datos mango. Bono

gratuito: Haga clic aquí para obtener acceso a un tutorial de vídeo libres Frasco + Python que muestra cómo construir aplicación web Frasco, paso a paso.

Actualizaciones :

  • 22/03/2016: actualizado a la versión 3.5.1 de Python, así como las últimas versiones de psycopg2, Frasco-SQLAlchemy y matraz de migrar. Véase más abajo para más detalles.
  • 02/22/2015: Agregado Python 3 apoyo.

Recuerde: Esto es lo que estamos construyendo – Un Frasco aplicación que calcula pares de palabras de frecuencia basado en el texto de una determinada URL.

Need el código? Agarrarlo desde el repositorio.

Requerimientos de Instalación Herramientas

utilizados en esta parte:

  • PostgreSQL (9.4)
  • psycopg2 (2.6.1) – un adaptador de Python para Postgres
  • matraz de SQLAlchemy (2.1) – Frasco extensión que proporciona soporte SQLAlchemy
  • matraz de migración (1.8.0) – extensión que soporta SQLAlchemy migraciones de bases de datos a través del alambique

Para empezar, instalar Postgres en su computadora local, si no lo tiene ya. Desde Heroku utiliza PostgreSQL, que será bueno para nosotros desarrollar localmente en la misma base de datos. Si no tiene instalado Postgres, Postgres.app es una manera fácil de poner en marcha para los usuarios de Mac OS X. Consulte la página de descarga para obtener más información.

Una vez que se han instalado Postgres y funcionando, crear una base de datos llamada wordcount_dev utilizar como nuestra base de datos de desarrollo local:

$ psql
# create database wordcount_dev;
CREATE DATABASE
# \q

Para poder utilizar nuestra base de datos de nueva creación dentro de la aplicación frasco que a necesidad de instalar un par de cosas:

$ cd flask-by-example

cding en el directorio debe activar el entorno virtual y establecer las variables de entorno encontraron en el archivo .env través autoenv, que hemos creado en la parte 1.

$ pip install psycopg2==2.6.1 Flask-SQLAlchemy===2.1 Flask-Migrate==1.8.0
$ pip freeze > requirements.txt

Si estás en OS X y que tiene verificación de la instalación psycopg2 problemas a cabo este Pila Artículo desbordamiento.

configuración de actualización de

Añadir campo SQLALCHEMY_DATABASE_URI a la clase Config () en el archivo config.py a configurar su aplicación para utilizar la base de datos de nueva creación en el desarrollo (local), puesta en escena, y la producción:

import os

class Config(object):
...
SQLALCHEMY_DATABASE_URI = os.environ['DATABASE_URL']

Su configuración archivo .py ahora debería tener este aspecto:

import os
basedir = os.path.abspath(os.path.dirname(__file__))

class Config(object):
DEBUG = False
TESTING = False
CSRF_ENABLED = True
SECRET_KEY = 'this-really-needs-to-be-changed'
SQLALCHEMY_DATABASE_URI = os.environ['DATABASE_URL']

class ProductionConfig(Config):
DEBUG = False

class StagingConfig(Config):
DEVELOPMENT = True
DEBUG = True

class DevelopmentConfig(Config):
DEVELOPMENT = True
DEBUG = True

class TestingConfig(Config):
TESTING = True

ahora, cuando nuestra configuración se carga en nuestra aplicación de la base de datos correspondiente se conectará a él también.

Similar a como hemos añadido una variable de entorno en el último post, vamos a añadir una variable DATABASE_URL. Ejecutar este en el terminal:

$ export DATABASE_URL="postgresql://localhost/wordcount_dev"

Y luego añadir que la línea en el archivo su .env.

En su app.py archivo de importación SQLAlchemy y de conexión a la base de datos:

from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
import os

app = Flask(__name__)
app.config.from_object(os.environ['APP_SETTINGS'])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

from models import Result

@app.route('/')
def hello():
return "Hello World!"

@app.route('/')
def hello_name(name):
return "Hello {}!".format(name)

if __name__ == '__main__':
app.run()

modelo de datos

Conjunto de un modelo de base, añadiendo un archivo models.py :

from app import db
from sqlalchemy.dialects.postgresql import JSON

class Result(db.Model):
__tablename__ = 'results'

id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String())
result_all = db.Column(JSON)
result_no_stop_words = db.Column(JSON)

def __init__(self, url, result_all, result_no_stop_words):
self.url = url
self.result_all = result_all
self.result_no_stop_words = result_no_stop_words

def __repr__(self):
return ''.format(self.id)

Aquí hemos creado una tabla para almacenar los resultados de las palabra cuenta.

Primero importar la conexión de base de datos que hemos creado en nuestro archivo app.py , así como JSON de dialectos de PostgreSQL SQLAlchemy. JSON columnas son bastante nuevo en Postgres y no están disponibles en cada base de datos soportado por SQLAlchemy por lo que necesitamos para importar específicamente.

A continuación creamos una clase Resultado () y le asignó el nombre de una tabla de resultados. A continuación, establecemos los atributos que queremos almacenar para un result-

  • el identificador del resultado que nos guardaron
  • la url que contamos con las palabras de
  • una lista completa de palabras que contamos
  • una lista de palabras que contamos con las palabras vacías menos (más sobre esto más adelante)

a continuación, creamos un () método __init __ que se ejecutará la primera vez que creamos un nuevo resultado y el método, por último, una __repr __ () para representar el objeto cuando nos consulta para ello.

local Migración

Vamos a utilizar Alambique, que forma parte del matraz de Migración, para gestionar las migraciones de bases de datos para actualizar el esquema de una base de datos.

Crear un nuevo archivo llamado manage.py :

import os
from flask.ext.script import Manager
from flask.ext.migrate import Migrate, MigrateCommand

from app import app, db

app.config.from_object(os.environ['APP_SETTINGS'])

migrate = Migrate(app, db)
manager = Manager(app)

manager.add_command('db', MigrateCommand)

if __name__ == '__main__':
manager.run()

Para utilizar matraz de Migración nos importó Gestor, así como migrar y MigrateCommand a nuestro archivo manage.py . También hemos importado aplicación y db por lo que tenemos acceso a ellos desde dentro del script.

En primer lugar, hemos establecido nuestra config para conseguir nuestro medio ambiente – en base a la variable de entorno – creado una instancia de migración, la aplicación y el PP como los argumentos, y estableció un comando encargado de inicializar una instancia de Manager para nuestra aplicación. Por último, agregamos el comando db con el gerente para que podamos ejecutar las migraciones desde la línea de comandos.

Con el fin de ejecutar las migraciones inicializar Alambique:

$ python manage.py db init
Creating directory /flask-by-example/migrations ... done
Creating directory /flask-by-example/migrations/versions ... done
Generating /flask-by-example/migrations/alembic.ini ... done
Generating /flask-by-example/migrations/env.py ... done
Generating /flask-by-example/migrations/README ... done
Generating /flask-by-example/migrations/script.py.mako ... done
Please edit configuration/connection/logging settings in
'/flask-by-example/migrations/alembic.ini' before proceeding.

Después de ejecutar la base de datos de inicialización, verá una nueva carpeta llamada “migraciones” en el proyecto. Esto es necesario para la configuración del alambique a las migraciones dirigidas contra el proyecto. Dentro de las “migraciones” verá que tiene una carpeta llamada “versiones”, que contendrá los scripts de migración a medida que se crean.

Vamos a crear nuestra primera migración mediante la ejecución del comando migrate.

$ python manage.py db migrate
INFO [alembic.runtime.migration] Context impl PostgresqlImpl.
INFO [alembic.runtime.migration] Will assume transactional DDL.
INFO [alembic.autogenerate.compare] Detected added table 'results'
Generating /flask-by-example/migrations/versions/63dba2060f71_.py
... done

Ahora se dará cuenta de sus “versiones” carpeta hay un archivo de migración. Este archivo es por Alambique basado en el modelo de auto-generado. Se podría generar (o editar) este archivo usted mismo; Sin embargo, para la mayoría de los casos va a hacer el archivo generado automáticamente.

Ahora vamos a aplicar las mejoras a la base de datos utilizando el comando de actualización db:

$ python manage.py db upgrade
INFO [alembic.runtime.migration] Context impl PostgresqlImpl.
INFO [alembic.runtime.migration] Will assume transactional DDL.
INFO [alembic.runtime.migration] Running upgrade -> 63dba2060f71, empty message

La base de datos está ahora lista para usarla en nuestra aplicación:

$ psql
# \c wordcount_dev
You are now connected to database "wordcount_dev" as user "michaelherman".
# \dt

List of relations
Schema | Name | Type | Owner
--------+-----------------+-------+---------------
public | alembic_version | table | michaelherman
public | results | table | michaelherman
(2 rows)

# \d results
Table "public.results"
Column | Type | Modifiers
----------------------+-------------------+------------------------------------------------------
id | integer | not null default nextval('results_id_seq'::regclass)
url | character varying |
result_all | json |
result_no_stop_words | json |
Indexes:
"results_pkey" PRIMARY KEY, btree (id)

remoto Migración

Por último, vamos a aplicar las migraciones a las bases de datos en Heroku. En primer lugar, sin embargo, tenemos que añadir los detalles de las bases de datos de ensayo y producción en el fichero de config.py . cheque

Para si tenemos una base de datos creada en la carrera servidor de ensayo:

$ heroku config --app wordcount-stage
=== wordcount-stage Config Vars
APP_SETTINGS: config.StagingConfig

Asegúrese de reemplazar wordcount-escenario con el nombre de su aplicación puesta en escena.

Dado que no vemos una variable de entorno de base de datos, tenemos que añadir el complemento de Postgres para el servidor de ensayo. Para ello, ejecute el siguiente comando:

$ heroku addons:create heroku-postgresql:hobby-dev --app wordcount-stage
Creating postgresql-cubic-86416... done, (free)
Adding postgresql-cubic-86416 to wordcount-stage... done
Setting DATABASE_URL and restarting wordcount-stage... done, v8
Database has been created and is available
! This database is empty. If upgrading, you can transfer
! data from another database with pg:copy
Use `heroku addons:docs heroku-postgresql` to view documentation.

manía-dev es la capa gratuita del complemento Heroku Postgres.

Ahora, cuando se corre heroku config –app wordcount-escenario de nuevo hay que ver los ajustes de conexión para la base de datos:

=== wordcount-stage Config Vars
APP_SETTINGS: config.StagingConfig
DATABASE_URL: postgres://azrqiefezenfrg:Zti5fjSyeyFgoc-U-yXnPrXHQv@ec2-54-225-151-64.compute-1.amazonaws.com:5432/d2kio2ubc804p7

siguiente que necesitamos para confirmar los cambios que ha realizado en Git y empuje para el servidor de transición:

$ git push stage master

Ejecutar las migraciones que hemos creado para migrar nuestra base de datos provisional mediante el comando de ejecución heroku:

$ heroku run python manage.py db upgrade --app wordcount-stage
Running python manage.py db upgrade on wordcount-stage... up, run.5677
INFO [alembic.runtime.migration] Context impl PostgresqlImpl.
INFO [alembic.runtime.migration] Will assume transactional DDL.
INFO [alembic.runtime.migration] Running upgrade -> 63dba2060f71, empty message

Aviso la forma en que sólo salía de la actualización, no es el init o comandos migran como antes. Ya hemos establecido nuestro archivo de migración y listo para funcionar; sólo tenemos que aplicarlo contra la base de datos Heroku.

Vamos ahora a hacer lo mismo para la producción.

Ahora, tanto nuestros sitios de ensayo y producción han establecido sus bases de datos y se migran – y listo para ir!

Cuando se aplica una nueva migración de la base de datos de producción, no podría ser el tiempo de inactividad. Si esto es un problema, puede configurar la replicación de bases de datos mediante la adición de un “seguidor” (comúnmente conocido como esclavo) de base de datos. Para más información sobre esto, echa un vistazo a la documentación oficial Heroku.

Conclusión

Eso es todo por parte 2. Si desea profundizar en el frasco, visita nuestra serie de videos que acompaña: Bonus

gratuito: Haga clic aquí para obtener acceso a un vídeo gratuito + Frasco Python tutorial que le muestra cómo construir aplicación web Frasco, paso a paso.

En la parte 3 vamos a construir la funcionalidad de conteo de palabras y lo han enviado a una cola de tareas para tratar con el procesamiento de recuento de palabras ya en funcionamiento.

Nos vemos la próxima vez. ¡Salud!

Esta es una pieza colaboración entre la leva Linke, co-fundador de inicio Edmonton, y la gente en el Real Python.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *