Escreva aplicações web assíncronas com python3 + tornado

Escreva aplicações web
assíncronas com Python3 +
Tornado
Wilson Júnior

Wilson Júnior
Há 3 anos trabalhando como
developer na Globo.com, apaixonado
por tecnologia e pessoas.
Entusiasta com python desde os 14
anos de idade.
Goiano, cerrado roots!

Entendendo as bases do
asyncronismo

Uma aplicação pode ser dividida
em 2 tempos

CPU Bound
Tempo que sua aplicação está voltada
apenas para o uso do processador ...

CPU Bound (exemplos)
● Cálculos matemáticos pesados
● Conversão de imagens
● Encoding de vídeo

IO Bound
Tempo que sua aplicação está voltada
apenas para comunicação com
interfaces de saída como:

IO Bound
● Comunicação com serviços
externos (banco de dados, HTTP,
redis, etc)
● Comunicação com dispositivos
locais (HD, Fita, DVD, pendrive, etc)

O que acontece quando fazemos
uma chamada que faz IO no
python

Exemplo de aplicação IO Bound
import requests
url = 'https://www.google.com.br'
response = requests.get(url, timeout=10)

Se este request HTTP demorar 10
segundos, o que acontece com a
aplicação ?

O que vem acontecendo nos
últimos anos com nossas
aplicações ...

O número de clientes das
aplicações mudou!

O número de clientes das aplicações mudou!

Otimizar o tempo de IO para
alcançarmos maior número de
clientes.

Então temos o IOLoop!
● Funciona como um "for" global
● Troca o contexto e retorna quando o IO finalizar
● Simples e fácil uso
● Multi plataforma (select, epoll, poll, kqueue) Windows, Linux e BSD

O que um ioloop trouxe de
melhoria

As aplicações não ficam travadas
em IOWait!

Não bloqueie o IOLoop com
operações que querem alto cpu
bound!

Aprenda a separar IO bound de
CPU bound

Podemos fazer o seguinte
approach!

Funções que fazem IO são async!

Funções que não fazem IO são
tradicionais

Funções que fazem IO
async def async_func():
# do something async

E como pego o retorno de uma
função assíncrona ?!

Funções que fazem IO
async def async_func():
# do something async
async def blah():
ret = await async_func()

Só posso fazer await dentro de
outra função assíncrona!

Tornado web framework!
tornadoweb.org

Características
● Escalável, não bloqueante;
● Nasceu na friendfeed; que foi vendida para o Facebook; hoje é mantido
pela comunidade;
● Pode manter milhares de conexões abertas;
● Possui um IO não bloqueante

Vamos começar um projetinho
em tornado ?!

Primeiro step: crie um virtualenv
com python 3.6

Primeiro step: crie um virtualenv com python 3.6
$ which python3.6
/usr/local/bin/python3.6
$ mkvirtualenv myproject -p /usr/local/bin/python3.6

Segundo step: instale o tornado
$ pip install tornado

from tornado.ioloop import IOLoop
from tornado.web import (
Application,
RequestHandler,
)
class HelloWorldHandler(RequestHandler):
def get(self):
self.write("Hello, world")

app = Application([
(r"/", HelloWorldHandler),
])
app.listen(8888)
IOLoop.current().start()

Fazendo requests utilizando
tornado

Novos imports
import json
Application,
RequestHandler,
)
from tornado.httpclient import AsyncHTTPClient

Realizando requests
async def get_http_result():
url = (
'https://raw.githubusercontent.com'
'/backstage/functions/master/package.json'
)
response = await AsyncHTTPClient().fetch(url,
validate_cert=False)
data = json.loads(response.body)
return {
'heey': data['name'],
}

Realizando requests
async def get(self):
result = await get_http_result()
self.write(json.dumps(result))

Cuidado com execução de
tarefas com o uso de CPU alto

Cuidado com execução de tarefas com o uso de CPU alto
# processamento de imagens pesadas
# cálculos pesados
# etc.

Cuidado com execução de
tarefas que façam IO sem usar
IOLoop

Cuidado com execução de tarefas que façam IO sem usar IOLoop
requests.get('https://host.com')

Teste assincronadamente
import unittest
from tornado.testing import AsyncTestCase, gen_test
from blah import get_http_result
class MyTest(AsyncTestCase):
@gen_test
async def test_ok(self):
result = await get_http_result()
self.assertEqual(result, {'heey': 'backstage-functions'})

Teste assincronadamente
$ pip install nose
$ nosetests test.py

Espere mais de uma operação
assíncrona

Espere mais de uma operação assíncrona
from tornado import gen
result01, result02 = await gen.multi([
get_http_result(),
get_http_result(),
])
self.write(json.dumps([result01, result02]))

Busque a lib não bloqueante para
o que você vai utilizar.

MySQL:
github.com/PyMySQL/Tornado-M
ySQL

Redis:
github.com/aio-libs/aioredis

Stomp:
github.com/wpjunior/torstomp

Alternativas para tarefas CPU
intensive

Execute assincronamente via ThreadPoolExecutor
● Vantagens
○ Fica tudo auto-contido dentro de um
app
○ Único processo para manter de pé
● Desvantagens
○ Limitado ao número de threads
○ Processo caiu perdeu jobs

Use um ThreadPoolExecutor
import time
from tornado import gen
Application,
RequestHandler,
)
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor

class ThreadPoolHandler(RequestHandler):
_thread_pool = ThreadPoolExecutor(10)
@gen.coroutine
def get(self):
result = yield self.sync_job()
self.write(result)
@run_on_executor(executor='_thread_pool')
def sync_job(self):
time.sleep(1)
return 'ok'

if __name__ == "__main__":
app = Application([
(r"/", ThreadPoolHandler),
], debug=True)
app.listen(8888)

Execute assincronamente via
barramento (noreply)

Execute assincronamente via barramento (noreply)
● Vantagens
○ Worker pode ser escrito em outra
linguaguem
○ Possibilidade de escalar em muitas
máquinas
○ Bufferização de tasks em uma fila
persistente
● Desvantagens
○ Mais um processo para manter

Execute assincronamente via barramento (noreply)

Tutorial: API Restful usando
motor + tornado

Tutorial: API Restful usando motor +
tornado
● instalaremos o mongo local
● $ pip install motor

Tutorial: API Restful usando motor + tornado
import json
import uuid
Application,
RequestHandler,
)
from motor.motor_tornado import MotorClient

class CollectionNameMixin(object):
@property
def collection_name(self):
raise NotImplementedError
def set_default_headers(self):
self.set_header('content-type', 'application/json')
@property
def collection(self):
return self.application.db[self.collection_name]

class BaseCollectionHandler(
CollectionNameMixin, RequestHandler):
result = []
async for document in self.collection.find({}):
result.append(document)

class BaseCollectionHandler(
CollectionNameMixin, RequestHandler):
async def post(self):
body = json.loads(self.request.body)
body['_id'] = str(uuid.uuid4())
await self.collection.insert_one(body)
self.write(json.dumps(body))

class BaseResourceHandler(CollectionNameMixin,
RequestHandler):
async def get(self, resource_id):
where = {"_id": resource_id}
result = await self.collection.find_one(where)
if not result:
self.set_status(404)
self.write('{"error": "Not found"}')
return

RequestHandler):
async def put(self, resource_id):
body = json.loads(self.request.body)
result = await self.collection.update_one(
{'_id': resource_id},
{'$set': body}
)
await self.get(resource_id)

RequestHandler):
async def delete(self, resource_id):
where = {'_id': resource_id}
result = await self.collection.delete_many(where)
if result.deleted_count == 0:
self.write('{"error": "Not found"}')
return

class PeopleCollectionHandler(BaseCollectionHandler):
collection_name = 'people'
class PeopleResourceHandler(BaseResourceHandler):
collection_name = 'people'

def get_app(db_name='blah'):
app = Application([
(r"/people", PeopleCollectionHandler),
(r"/people/(.*)", PeopleResourceHandler),
])
app.db = MotorClient()[db_name]
return app
if __name__ == "__main__":
get_app().listen(8888)

Vamos testar nossa aplicação ?!

import json
from tornado.testing import AsyncHTTPTestCase, gen_test
from rest_mongo import get_app

class MyTest(AsyncHTTPTestCase):
def get_app(self):
return get_app('test-database')
def setUp(self):
super().setUp()
def drop_collection_result(*args):
self.stop()
self.get_app().db.drop_collection(
'people', callback=drop_collection_result)
self.wait()

def test_not_found(self):
response = self.fetch('/people/1234')
self.assertEqual(response.code, 404)
self.assertEqual(response.headers['content-type'],
'application/json')
body = json.loads(response.body)
self.assertEqual(body, {'error': 'Not found'})

def test_create_and_get(self):
# create
response = self.fetch('/people', method='POST',
body='{"name": "created"}')
'application/json')
self.assertEqual(body['name'], 'created')

def test_create_and_get(self):
...
# get
response = self.fetch('/people/%s' % body["_id"])
'application/json')
self.assertEqual(body['name'], 'created')

Tutorial resolvido
github.com/wpjunior/python36-a
sync

Obrigado
github.com/wpjunior about.me/wpjunior

Temos projetos em tornado, venha trabalhar
na Globo.com
talentos.globo.com
Projetos

Escreva aplicações web assíncronas com python3 + tornado

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Escreva aplicações web assíncronas com python3 + tornado

Similar a Escreva aplicações web assíncronas com python3 + tornado (20)

Más de Wilson Júnior

Más de Wilson Júnior (6)

Escreva aplicações web assíncronas com python3 + tornado