Desarrollo de aplicaciones Python sin servidor con AWS Chalice

    Introducción

    En el desarrollo de software, estamos constantemente creando soluciones para los usuarios finales que resuelven un problema en particular o facilitan / automatizan un determinado proceso. Por lo tanto, diseñar y construir el software no es la única parte del proceso, ya que tenemos que poner el software a disposición de los usuarios previstos.

    Para las aplicaciones basadas en web, la implementación es un aspecto muy importante y parte del proceso, ya que la aplicación no solo debe funcionar, sino que también debe funcionar para muchos usuarios al mismo tiempo y estar altamente disponible.

    Algunas de las opciones de implementación que tenemos a nuestra disposición incluyen comprar nuestro propio hardware de servidor e implementar nuestras aplicaciones o alquilar espacio de servidor en otras empresas. Esto tiene un costo no solo de los recursos necesarios para adquirirlos, sino también de los costos de mantenimiento y del personal para monitorear los recursos del servidor.

    ¿Qué pasaría si pudiéramos hacer que nuestra aplicación estuviera disponible sin tener que preocuparnos por aprovisionar servidores o mantenerlos? Nuestra agilidad y entrega mejorarían enormemente.

    Podemos lograr esto a través de una plataforma informática sin servidor como AWS Lambda, que está disponible por Servicios web de Amazon.

    ¿Qué es la informática sin servidor?

    Los proveedores de la nube ofrecen diferentes soluciones para implementar y ejecutar aplicaciones, una de ellas es la informática sin servidor. En esta arquitectura, el proveedor de la nube aloja sus aplicaciones y asume las responsabilidades de la gestión del servidor en términos de software y hardware. Piense en ello como una infraestructura como servicio (IaaS).

    El proveedor de la nube se encarga del escalado, la disponibilidad, el mantenimiento del servidor y la configuración, entre otras cosas, de modo que, como desarrolladores, nuestro enfoque está completamente en nuestro código. Esto, a su vez, reduce la sobrecarga necesaria para que nuestras aplicaciones se ejecuten y estén disponibles para nuestros usuarios finales.

    La computación sin servidor tiene sus ventajas, pero también presenta algunos inconvenientes, como que el desarrollador se limita a las opciones o herramientas que utiliza el proveedor para fines como el registro, el seguimiento y la supervisión, y el desarrollador no puede utilizar sus propias herramientas. Además, como desarrollador, está atado a la disponibilidad del proveedor, si experimentan problemas o interrupciones, nuestra aplicación también se verá afectada.

    AWS es un proveedor de nube líder que ofrece informática sin servidor a través de AWS Lambda. Este es un tiempo de ejecución de computación sin servidor que permite a los desarrolladores ejecutar su código en respuesta a ciertos eventos de los usuarios, como hacer una solicitud o cargar archivos en un Cubo S3.

    Este servicio también nos permite pagar solo por los recursos informáticos que utilizamos en lugar de un costo general por los servicios. Esto sucede a través de una función Lambda que escala para adaptarse a la escala y es independiente de la infraestructura subyacente.

    ¿Qué es el cáliz?

    Cáliz es un microframework para crear e implementar rápidamente aplicaciones sin servidor en Python para funciones de AWS Lambda. Chalice no solo nos ayuda a crear aplicaciones de Python, sino también a implementarlas rápidamente al proporcionar una herramienta de línea de comandos para crear, administrar e implementar nuestra aplicación.

    Chalice también brinda funcionalidad de integración a otros servicios de Amazon como Amazon API Gateway, Amazon Simple Storage Service (S3) y Simple Queue Service (SQS), entre otros. Podemos crear API RESTful, tareas que se ejecutan en un horario determinado o que se integran al bucket de S3 para su almacenamiento.

    Preparar

    Configuración de AWS

    Para comenzar con Chalice, necesitamos tener una cuenta de AWS configurada para interactuar e implementar nuestro código. Esto se puede lograr a través del Página de inicio de AWS donde podemos registrarnos o iniciar sesión en una cuenta de AWS existente. AWS requiere que no solo ofrezcamos nuestros datos, sino también los datos de facturación, pero para esta demostración utilizaremos el Capa gratuita de AWS con fines de prueba y desarrollo, por lo que no se nos facturará.

    Una vez que nuestra cuenta está configurada, en el menú desplegable de nuestro perfil, hay una sección llamada “Mis credenciales de seguridad”. Aquí podremos crear credenciales que se utilizarán al interactuar con la consola de AWS. Estas credenciales también serán utilizadas por la herramienta CLI de Amazon.

    Amazon también ofrece una herramienta CLI que podemos usar para interactuar con nuestros servicios de AWS usando comandos en nuestro terminal. Está disponible para plataformas Mac, Linux y Windows y requiere Python 2.6+ o Python 3.3 o una versión posterior. Podemos instalarlo ejecutando el siguiente comando pip:

    $ pip install awscli
    

    Una vez configurada, podemos probar la herramienta CLI ejecutando:

    $ aws --version
    

    Se pueden encontrar más detalles sobre la herramienta CLI y la instalación en otras plataformas Aquí.

    Con la configuración de la herramienta AWS CLI, usaremos las credenciales, es decir, la clave secreta y el ID de acceso, que generamos anteriormente para configurar nuestra herramienta CLI ejecutando:

    $ aws configure
    

    Recibiremos un mensaje para completar nuestro Access Key ID, Secret Access Key y regiones y formatos de salida predeterminados. Los dos últimos son opcionales pero necesitaremos la clave de acceso y el secreto que obtuvimos del tablero de la consola de AWS.

    También puede configurar diferentes credenciales para diferentes usuarios en AWS. Más sobre eso y otros detalles se pueden encontrar Aquí.

    Configuración del proyecto

    Para este proyecto de demostración, crearemos una aplicación Python y es una buena práctica trabajar dentro de un entorno virtual para mantener nuestro entorno de proyecto abstraído del entorno Python del sistema. Para este propósito, utilizaremos el Virtualenv herramienta para crear un entorno virtual dentro del cual trabajaremos.

    En caso de Virtualenv La herramienta aún no está instalada, podemos instalarla simplemente ejecutando:

    $ pip install virtualenv
    

    Puede encontrar más información sobre la herramienta Virtualenv Aquí.

    Con Virtualenv instalado, vayamos a nuestro directorio de trabajo y creemos un entorno ejecutando el siguiente comando:

    $ virtualenv --python=python3 venv-chalice
    

    Activaremos nuestro entorno ejecutando:

    $ source venv-chalice/bin/activate
    

    Nuestro entorno ahora está configurado, y ahora podemos instalar Chalice y verificar la instalación ejecutando los siguientes comandos:

    $ pip install chalice
    $ chalice --help
    

    El segundo comando aquí se usa simplemente para verificar la instalación de Chalice.

    Implementación

    Ahora tenemos una cuenta de AWS, la herramienta AWS CLI instalada, la configuración del entorno y Chalice instalado. Ahora podemos usar Chalice para crear nuestra API RESTful simple de la siguiente manera:

    $ chalice new-project demoapp
    

    Este comando crea un proyecto de cáliz simple dentro de una carpeta que tiene la siguiente estructura:

    $ tree demoapp
    demoapp
    ├── app.py
    └── requirements.txt
    

    Cualquier otro requisito que nuestra aplicación Chalice requiera para ejecutarse mientras se implementa en AWS Lambda se incluirá en el requirements.txt archivo dentro del demoapp carpeta, y nuestra nueva funcionalidad residirá principalmente en el app.py archivo. Podemos crear otros archivos e importarlos al app.py archivo, que es nuestro archivo de proyecto principal.

    Para nuestra API simple, crearemos una API que devuelva una lista de los repositorios públicos de GitHub de un usuario, los idiomas utilizados en cada uno y la cantidad de estrellas que tiene el repositorio. Esta información está disponible públicamente en la API de GitHub, por lo tanto, no necesitaremos credenciales para interactuar con la API. Crearemos una función que recibe un nombre de usuario y devuelve los detalles que requerimos. Si el nombre de usuario proporcionado no existe, recibiremos una carga útil de respuesta vacía.

    Creemos el github_repos función que será responsable de la interacción API de GitHub:

    import requests
    
    def github_repos(username):
        # Final list to contain our repository objects
        formatted_repos = []
    
        if username:
            # Format the url by insterting the passed username
            url = "https://api.github.com/users/{}/repos".format(username)
    
            r = requests.get(url)
    
            # Get the JSON containing the list of repositories
            list_of_repos = r.json()
    
            for repo in list_of_repos:
                repo_object = {
                  "name": repo["name"],
                  "stars": repo["watchers"],
                  "language": repo["language"],
                }
    
                formatted_repos.append(repo_object)
    
        return formatted_repos
    

    La función github_repos recibe un nombre de usuario y lo conecta a la URL de la API de GitHub antes de realizar la solicitud. La respuesta recibida tiene mucha información que no necesitamos por ahora, por lo que extraemos los detalles de un repositorio que necesitamos, creamos un nuevo objeto y lo agregamos a la lista de formatted_repos que enviaremos de vuelta al usuario a través de la aplicación Chalice.

    Primero ejecutemos algunas pruebas locales para nuestra función y este es el resultado:

    La función ya está lista para integrarse en nuestra aplicación Chalice en el app.py archivo, y esta es la versión final de nuestra aplicación:

    import requests
    from chalice import Chalice
    
    def github_repos(username):
        # Function implementation above
    
    app = Chalice(app_name="demoapp")
    
    @app.route("https://Pharos.sh.com/")
    def index():
        return {'hello': 'world'}
    
    # Create our new route to handle github repos functionality
    @app.route('/user/{username}')
    def github(username):
        return {"repos": github_repos(username)}
    

    Nuestra aplicación ahora está lista para ser consumida por los usuarios, impleméntela ahora en AWS Lambda.

    Implementando nuestra aplicación

    La implementación de una aplicación Chalice en AWS Lambda es tan simple como ejecutar el siguiente comando en nuestro directorio de trabajo:

    $ chalice deploy
    

    Chalice se encargará del proceso de implementación por nosotros y nos devolverá un enlace con el que podemos interactuar con la API RESTful que acabamos de crear:

    Para probar nuestra API, podemos usar Cartero, un navegador web o cualquier otra herramienta de interacción API para realizar solicitudes al /user/<github-username> punto final en la “URL de la API REST” de la captura de pantalla anterior. Pasé mi nombre de usuario de GitHub y este fue el resultado:

    Si hacemos algún cambio en nuestro código, simplemente ejecutamos el chalice deploy comando de nuevo y Chalice volverá a implementar nuestra aplicación con los cambios que acabamos de hacer.

    Cuando nos dirigimos a la Consola de AWS y hacemos clic en la sección “Funciones” en la barra lateral plegable en el lado izquierdo, podemos ver la función Lambda que actualmente está ejecutando nuestra aplicación:

    Cuando hacemos clic en nuestra función, obtenemos más detalles sobre ella, como la configuración actual, las variables de entorno establecidas para nuestra aplicación, los roles de ejecución y la configuración de la memoria.

    AWS también nos brinda opciones de monitoreo como registros de eventos y métricas a través de CloudWatch que es un servicio de monitoreo y administración ofrecido por AWS.

    Esta es la vista del panel de monitoreo de nuestra aplicación:

    Obtenemos estadísticas sobre el número de invocaciones por parte de los usuarios, la duración de las solicitudes atendidas por nuestra API, las tasas de éxito y error, entre otras cosas.

    Incluso obtenemos una vista de las solicitudes individuales en el mismo panel, aunque esto no es visible en la captura de pantalla anterior. AWS hace mucho por nosotros de forma inmediata, lo que hace que nuestra experiencia de implementación sea breve y directa al grano. No tenemos que preocuparnos por mantener nuestro propio servidor o implementar nuestros propios métodos de monitoreo y registro, ya que AWS nos tiene cubierto para esto.

    Esta es la experiencia sin servidor.

    Resumen

    En este artículo, creamos una API de Python sin servidor utilizando el microframework Chalice y la implementamos en AWS Lambda. La AWS CLI, junto con las herramientas de Chalice CLI, nos ha ayudado a iniciar nuestro proyecto rápidamente y lo implementamos en AWS Lambda con un solo comando.

    La nuestra es una aplicación sin servidor, ya que no tuvimos que encargarnos de ninguna provisión o mantenimiento del servidor por nuestra parte. Simplemente escribimos el código y dejamos que AWS se encargue del resto por nosotros, incluida la implementación, el escalado y la supervisión de nuestra aplicación. El tiempo necesario para que nuestra aplicación esté disponible ha disminuido significativamente, a pesar de que todavía dependemos de AWS para otros aspectos, como la supervisión de nuestra aplicación.

    El código fuente de este proyecto está disponible aquí en GitHub.

     

    Etiquetas:

    Deja una respuesta

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