Categorías
Python

La última lista de canales de YouTube Python

 

Tabla de Contenidos

  • Introducción a AWS ChaliceWhy cáliz? SetupBuild Proyecto y Ejecución LocallyDeploy en AWS Lambda
  • Por qué cáliz? Configuración
  • Proyecto

  • generar y ejecutar localmente
  • Implementar en AWS Lambda
  • La construcción de un remitente ServiceBuild sin servidor SMS y Ejecutar LocallyDeploy en AWS Lambda
  • generar y ejecutar localmente
  • Implementar en AWS Lambda
  • Refactoring
  • cordura CheckBuild y Ejecutar LocallyDeploy en AWS Lambda
  • generar y ejecutar localmente
  • Implementar en AWS Lambda
  • Conclusión
  • por qué cáliz? Configuración
  • proyecto

  • generar y ejecutar localmente
  • Despliegue en AWS Lambda
  • generar y ejecutar localmente
  • Despliegue en AWS Lambda
  • generar y ejecutar localmente
  • Despliegue en AWS Lambda

el envío de una aplicación web por lo general consiste en tener su código y se ejecuta en uno o varios servidores. En este modelo, se termina la creación de procesos para el seguimiento, aprovisionamiento, y la ampliación de sus servidores hacia arriba o abajo. Aunque esto parece funcionar bien, tener toda la logística en torno a una aplicación web se maneja de una manera automatizada reduce mucha sobrecarga manual. Introduzca sin servidor. Con

sin servidor Arquitectura, que no logran servidores. En su lugar, sólo tiene que enviar el código o el paquete ejecutable para la plataforma que lo ejecuta. En realidad no es sin servidor. Los servidores existen, pero el desarrollador no tiene que preocuparse de ellos.

AWS introdujo Servicios Lambda, una plataforma que permite a los desarrolladores simplemente tienen su código ejecutado en un entorno de tiempo de ejecución en particular. Para hacer que la plataforma fácil de usar, muchas comunidades han llegado con algunos muy buenos marcos alrededor de ella con el fin de hacer que el sin servidor de aplicaciones de una solución de trabajo.

Al final de este tutorial, usted será capaz de :

  • discutir los beneficios de una arquitectura sin servidor
  • Explora cáliz, un pitón sin servidor marco
  • Construir una aplicación completa sin servidor soplado para un uso en el mundo real
  • caso

  • Implementar para Amazon web Services (AWS) Lambda
  • Comparar funciones puras y Lambda bonificación

gratuito: 5 pensamientos sobre Python maestría, un curso gratuito para los desarrolladores de Python que le muestra la hoja de ruta y el modo de pensar que usted necesitará tomar sus habilidades de Python al siguiente nivel.

Introducción a AWS cáliz

cáliz, un pitón sin servidor Microframework desarrollado por AWS, le permite girar rápidamente y desplegar una aplicación sin servidor de trabajo que las escalas arriba y abajo en su propio como lo requiere el uso de AWS Lambda.

Por qué cáliz? desarrolladores

para Python acostumbrados al framework web Frasco, cáliz debe ser una brisa en términos de construcción y el envío de su primera aplicación. Muy inspirado en el frasco, cáliz lo mantiene bastante minimalista en cuanto a la definición de lo que el servicio debe ser como y, finalmente, hacer un paquete ejecutable de la misma. La teoría

Basta! Empecemos con una aplicación de hola-mundo básica y a poner en marcha nuestro viaje sin servidor. Configuración

Proyecto

Antes de entrar en cáliz, que va a configurar un entorno de trabajo en el equipo local, que se pondrán en marcha para el resto del tutorial.

En primer lugar, crear y activar un entorno virtual e instalar cáliz:

$ python3.6 -m venv env
$ source env/bin/activate
(env)$ pip install chalice

Siga nuestra guía completa en la herramienta de empaquetado Pipenv.

Nota: cáliz viene con una CLI fácil de usar que hace que sea fácil de jugar con su aplicación sin servidor.

Ahora que tiene cáliz instalado en el entorno virtual, vamos a usar el cáliz de la CLI para generar algo de código repetitivo:

(env)$ chalice new-project

Introduzca el nombre del proyecto, cuando se le solicite y pulse Enter. Un nuevo directorio se crea con ese nombre:

/
|
├── .chalice/
│ └── config.json
|
├── .gitignore
├── app.py
└── requirements.txt

Vea cómo minimalista es el código base cáliz. Un directorio .chalice, app.py y requirements.txt es todo lo que se requiere que tenga una aplicación sin servidor en funcionamiento. Vamos a correr rápidamente la aplicación en nuestra máquina local.

cáliz CLI consiste realmente grandes funciones de utilidad que le permiten realizar una serie de operaciones que se ejecute localmente para el despliegue en un entorno Lambda.

generar y ejecutar localmente

Usted puede simular la aplicación mediante la ejecución a nivel local utilizando el servicio público local de cáliz:

(env)$ chalice local
Serving on 127.0.0.1:8000

Por defecto, cáliz ejecuta en el puerto 8000. Ahora podemos comprobar la ruta de índice al hacer una solicitud a http rizo : // localhost: 8000 /:

$ curl -X GET http://localhost:8000/
{"hello": "world"}

Ahora bien, si nos fijamos en app.py, podemos apreciar la sencillez con la que cáliz le permite construir un servicio sin servidor. Toda la materia compleja es manejado por los decoradores:

from chalice import Chalice
app = Chalice(app_name='serverless-sms-service')

@app.route('/')
def index():
return {'hello': 'world'}

Nota : No hemos llamado nuestra aplicación hola-mundo, como vamos a construir nuestro servicio de SMS en la misma aplicación.

Ahora, vamos a pasar a la implementación de nuestra aplicación en la AWS Lambda.

Implementar en AWS Lambda

cáliz hace que el despliegue de su aplicación sin servidor completamente sin esfuerzo. El uso de la utilidad de despliegue, puede simplemente instruir cáliz de implementar y crear una función lambda que puede ser accesible a través de una API REST.

Antes de comenzar el despliegue, tenemos que asegurarnos de que tenemos nuestras credenciales de AWS en el lugar, por lo general, en ~ / .AWS / config. El contenido del archivo se ve de la siguiente manera: las credenciales

[default]
aws_access_key_id=
aws_secret_access_key=
region=

con AWS en su lugar, vamos a empezar nuestro proceso de despliegue con un único comando:

(env)$ chalice deploy
Creating deployment package.
Updating policy for IAM role: hello-world-dev
Creating lambda function: hello-world-dev
Creating Rest API
Resources deployed:
- Lambda ARN: arn:aws:lambda:ap-south-1:679337104153:function:hello-world-dev
- Rest API URL: https://fqcdyzvytc.execute-api.ap-south-1.amazonaws.com/api/

Nota : La ARN generado y URL de la API en el fragmento anterior variará de un usuario al usuario.

Wow! Sí, es realmente tan fácil de conseguir su aplicación sin servidor en funcionamiento. Para comprobar simplemente hacer una solicitud rizo sobre el resto de la API URL generada:

$ curl -X GET https://fqcdyzvytc.execute-api.ap-south-1.amazonaws.com/api/
{"hello": "world"}

Típicamente, esto es todo lo que necesita para obtener su aplicación sin servidor en funcionamiento. También puede ir a la consola de AWS y ver la función Lambda creado bajo la sección de servicio Lambda. Cada servicio Lambda tiene un único punto final de la API REST que se puede consumir en cualquier aplicación web.

A continuación, se iniciará la construcción de su servicio de SMS del remitente sin servidor utilizando Twilio como un proveedor de servicios SMS.

La construcción de un remitente sin servidor SMS Servicio

Con una aplicación básica hola-mundo desplegado, vamos a pasar a la construcción de una aplicación más del mundo real que se puede utilizar junto con aplicaciones web todos los días. En esta sección, usted construirá una aplicación de envío de SMS-completamente sin servidor que puede ser conectado a cualquier sistema y el trabajo como se esperaba, siempre y cuando los parámetros de entrada son correctos.

Con el fin de enviar SMS, que va a utilizar Twilio, un servicio de SMS amistoso con el desarrollador. Antes de comenzar el uso de Twilio, tenemos que tener cuidado de unos requisitos previos:

  • Crear una cuenta y adquirir ACCOUNT_SID y auth_token.
  • Obtener un número de teléfono móvil, que está disponible de forma gratuita en Twilio para la materia de las pruebas de menor importancia.
  • Instala el paquete Twilio en nuestro entorno virtual utilizando pip instalar Twilio.

Con todos los requisitos anteriores marcada, puede empezar a construir su cliente de servicios de SMS utilizando la biblioteca de Python de Twilio. Vamos a empezar por clonación del repositorio y la creación de una nueva rama de la característica:

$ git clone $ cd $ git checkout tags/1.0 -b twilio-support

Ahora hacer los siguientes cambios en app.py evolucionando desde una aplicación simple hola-mundo para habilitar el soporte para el servicio Twilio también.

En primer lugar, vamos a incluir todas las declaraciones de importación:

from os import environ as env

# 3rd party imports
from chalice import Chalice, Response
from twilio.rest import Client
from twilio.base.exceptions import TwilioRestException

# Twilio Config
ACCOUNT_SID = env.get('ACCOUNT_SID')
AUTH_TOKEN = env.get('AUTH_TOKEN')
FROM_NUMBER = env.get('FROM_NUMBER')
TO_NUMBER = env.get('TO_NUMBER')

A continuación, usted encapsular la API Twilio y lo utilizan para enviar SMS:

app = Chalice(app_name='sms-shooter')

# Create a Twilio client using account_sid and auth token
tw_client = Client(ACCOUNT_SID, AUTH_TOKEN)

@app.route('/service/sms/send', methods=['POST'])
def send_sms():
request_body = app.current_request.json_body
if request_body:
try:
msg = tw_client.messages.create(
from_=FROM_NUMBER,
body=request_body['msg'],
to=TO_NUMBER)

if msg.sid:
return Response(status_code=201,
headers={'Content-Type': 'application/json'},
body={'status': 'success',
'data': msg.sid,
'message': 'SMS successfully sent'})
else:
return Response(status_code=200,
headers={'Content-Type': 'application/json'},
body={'status': 'failure',
'message': 'Please try again!!!'})
except TwilioRestException as exc:
return Response(status_code=400,
headers={'Content-Type': 'application/json'},
body={'status': 'failure',
'message': exc.msg})

En el fragmento anterior, sólo tiene que crear un objeto de cliente Twilio usando ACCOUNT_SID y auth_token y utilizarlo para enviar mensajes bajo el punto de vista Send_SMS. Send_SMS es un esqueleto de función que utiliza la API de cliente Twilio para enviar el SMS al destino especificado. Antes de seguir adelante, vamos a darle una oportunidad y ejecutarlo en nuestra máquina local.

generar y ejecutar localmente

Ahora se puede ejecutar la aplicación en su máquina utilizando la utilidad local y comprobar que todo está funcionando bien:

(env)$ chalice local

Ahora haga una petición POST rizo a http: // localhost: 8000 / servicio / sms / envío con una carga específica y la prueba de la aplicación a nivel local:

$ curl -H "Content-Type: application/json" -X POST -d '{"msg": "hey mate!!!"}' http://localhost:8000/service/sms/send

la anterior solicitud responde de la siguiente manera:

{
"status": "success",
"data": "SM60f11033de4f4e39b1c193025bcd5cd8",
"message": "SMS successfully sent"
}

la respuesta indica que el mensaje fue enviado con éxito. Ahora, vamos a pasar a la implementación de la aplicación en AWS Lambda.

Implementar en AWS Lambda

Como se sugiere en la sección de implementación anterior, sólo tiene que ejecutar el siguiente comando:

(env)$ chalice deploy
Creating deployment package.
Updating policy for IAM role: sms-shooter-dev
Creating lambda function: sms-shooter-dev
Creating Rest API
Resources deployed:
- Lambda ARN: arn:aws:lambda:ap-south-1:679337104153:function:sms-shooter-dev
- Rest API URL: https://qtvndnjdyc.execute-api.ap-south-1.amazonaws.com/api/

Nota : El comando anterior tiene éxito, y usted tiene su URL de la API en la salida como se esperaba. Ahora en las pruebas de la URL, el API genera un mensaje de error. ¿Qué salió mal?

De acuerdo con los registros de AWS Lambda, Twilio paquete no se encuentra o instalado, por lo que necesita para decirle al servicio de Lambda para instalar las dependencias. Para ello, es necesario agregar Twilio como una dependencia a requirements.txt:

twilio==6.18.1

otros paquetes como cáliz y sus dependencias no debería incluirse en requirements.txt, ya que no son una parte del tiempo de ejecución WSGI de Python. En cambio, debemos mantener un dev.txt-requisitos, que se aplica a sólo el entorno de desarrollo y contiene todas las dependencias relacionadas con el cáliz. Para obtener más información, echa un vistazo a este tema GitHub.

Una vez que se clasifican todas las dependencias del paquete, lo que necesita para asegurarse de que todas las variables de entorno también se envían a lo largo y configurados correctamente durante el tiempo de ejecución Lambda. Para ello, hay que añadir todas las variables de entorno en .chalice / config.json de la siguiente manera:

{
"version": "2.0",
"app_name": "sms-shooter",
"stages": {
"dev": {
"api_gateway_stage": "api",
"environment_variables": {
"ACCOUNT_SID": "",
"AUTH_TOKEN": "",
"FROM_NUMBER": "",
"TO_NUMBER": ""
}
}
}
}

Ahora estamos listos para desplegar:

Creating deployment package.
Updating policy for IAM role: sms-shooter-dev
Updating lambda function: sms-shooter-dev
Updating rest API
Resources deployed:
- Lambda ARN: arn:aws:lambda:ap-south-1:679337104153:function:sms-shooter-dev
- Rest API URL: https://fqcdyzvytc.execute-api.ap-south-1.amazonaws.com/api/

Realice una comprobación al hacer una petición a la curvatura generada API de punto final:

$ curl -H "Content-Type: application/json" -X POST -d '{"msg": "hey mate!!!"}' https://fqcdyzvytc.execute-api.ap-south-1.amazonaws.com/api/service/sms/send

La anterior solicitud responde como se esperaba:

{
"status": "success",
"data": "SM60f11033de4f4e39b1c193025bcd5cd8",
"message": "SMS successfully sent"
}

Ahora, usted tiene un SMS completamente sin servidor que envía el servicio en funcionamiento. Con el extremo delantero de este servicio es una API REST, que puede ser utilizado en otras aplicaciones como una característica plug-and-play que es escalable, segura y fiable.

Refactoring

Por último, vamos a refactorizar nuestra aplicación SMS para que no contenga toda la lógica del negocio en app.py por completo. En su lugar, vamos a seguir el cáliz prescrito mejores prácticas y el resumen de la lógica de negocio bajo el chalicelib / directorio. de

Que comience mediante la creación de una nueva rama:

$ git checkout tags/2.0 -b sms-app-refactor

En primer lugar, crear un nuevo directorio en el directorio raíz del proyecto denominado chalicelib / y crear un nuevo archivo llamado sms.py:

(env)$ mkdir chalicelib
(env)$ touch chalicelib/sms.py

actualización de lo anterior creado chalicelib / SMS. py con el envío de SMS mediante la abstracción de la lógica de las cosas app.py:

from os import environ as env
from twilio.rest import Client

# Twilio Config
ACCOUNT_SID = env.get('ACCOUNT_SID')
AUTH_TOKEN = env.get('AUTH_TOKEN')
FROM_NUMBER = env.get('FROM_NUMBER')
TO_NUMBER = env.get('TO_NUMBER')

# Create a twilio client using account_sid and auth token
tw_client = Client(ACCOUNT_SID, AUTH_TOKEN)

def send(payload_params=None):
""" send sms to the specified number """
msg = tw_client.messages.create(
from_=FROM_NUMBER,
body=payload_params['msg'],
to=TO_NUMBER)

if msg.sid:
return msg

el anterior fragmento sólo acepta los parametros de entrada y responde según sea necesario. Ahora bien, para que esto funcione, tenemos que hacer cambios a app.py así:

# Core imports
from chalice import Chalice, Response
from twilio.base.exceptions import TwilioRestException

# App level imports
from chalicelib import sms

app = Chalice(app_name='sms-shooter')

@app.route('/')
def index():
return {'hello': 'world'}

@app.route('/service/sms/send', methods=['POST'])
def send_sms():
request_body = app.current_request.json_body
if request_body:
try:
resp = sms.send(request_body)
if resp:
return Response(status_code=201,
headers={'Content-Type': 'application/json'},
body={'status': 'success',
'data': resp.sid,
'message': 'SMS successfully sent'})
else:
return Response(status_code=200,
headers={'Content-Type': 'application/json'},
body={'status': 'failure',
'message': 'Please try again!!!'})
except TwilioRestException as exc:
return Response(status_code=400,
headers={'Content-Type': 'application/json'},
body={'status': 'failure',
'message': exc.msg})

En el fragmento anterior, toda la lógica de envío de SMS se invoca desde el módulo de los chalicelib.sms, haciendo que la capa de vista mucho más limpio en términos de legibilidad. Esta abstracción permite añadir mucho más compleja lógica de negocio y personalizar la funcionalidad que se requiere.

cordura Compruebe

Después de refactorización nuestro código, vamos a asegurar que está funcionando como se esperaba.

generar y ejecutar localmente

Ejecutar la aplicación una vez más el uso de los servicios públicos locales:

(env)$ chalice local

Efectúe una petición rizo y verificar. Una vez hecho esto, pasar a la implementación.

Implementar en AWS Lambda

Una vez que esté seguro de que todo está funcionando como se esperaba, ahora puede finalmente desplegar su aplicación:

(env)$ chalice deploy

Como de costumbre, el comando se ejecute con éxito y se puede verificar el punto final.

Conclusión

Ahora ya sabe cómo hacer lo siguiente:

  • Construir una aplicación sin servidor utilizando AWS cáliz de conformidad con las mejores prácticas
  • Implementar la aplicación de trabajo en el entorno de ejecución Lambda servicios

Lambda bajo el capó son análogos a funciones puras, que tienen un cierto comportamiento en un conjunto de entrada / salida. El desarrollo de los servicios precisos Lambda permite una mejor prueba, la legibilidad y la atomicidad. Desde cáliz es un marco minimalista, sólo puede centrarse en la lógica de negocio, y el resto es atendido, desde el despliegue de la generación de políticas IAM. Todo esto es con un solo despliegue de comandos!

Además, los servicios Lambda se centran principalmente en el procesamiento unido CPU pesada y la escala de una manera auto-gobernados, como por el número de solicitudes en una unidad de tiempo. Utilizando la arquitectura sin servidor permite a su base de código a ser más como SOA (Service Oriented Architecture). El uso de otros productos de AWS en su ecosistema que se conectan bien con las funciones lambda es aún más potente.

Deja un comentario

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