Gestión de archivos con AWS S3, Python y Flask

    Introducción

    Uno de los factores impulsores clave para el crecimiento de la tecnología son los datos. Los detalles ahora son cada vez más importantes sobre las herramientas que se crean a medida que avanza la tecnología. Ahora es un factor impulsor del crecimiento de la tecnología, cómo recopilar, almacenar, proteger y distribuir datos.

    Este crecimiento de datos ha llevado a un aumento en el uso de la arquitectura en la nube para almacenar y administrar datos mientras se minimiza el problema requerido para mantener la consistencia y precisión. Como consumidores de tecnología, estamos generando y consumiendo datos y, como resultado, hemos necesitado sistemas elaborados para ayudarnos a administrar los datos.

    La arquitectura de la nube nos brinda la capacidad de cargar y descargar archivos desde múltiples dispositivos mientras estamos conectados a Internet. Y eso es parte de lo que AWS nos ayuda a lograr a través de los buckets S3.

    ¿Qué es S3?

    Servicio de almacenamiento simple de Amazon (S3) es una oferta de Amazon Web Services (AWS) que permite a los usuarios almacenar datos en forma de objetos. Está diseñado para servir a usuarios de todo tipo, desde empresas hasta pequeñas organizaciones o proyectos personales.

    S3 se puede utilizar para almacenar datos desde imágenes, video y audio hasta copias de seguridad o datos estáticos de sitios web, entre otras cosas.

    Bucket S3 es un recurso de almacenamiento designado que se utiliza para almacenar datos en AWS. Es como una carpeta que se utiliza para almacenar datos en AWS. Los depósitos tienen nombres únicos y, según la serie y el precio, los usuarios obtienen diferentes niveles de redundancia y accesibilidad a diferentes precios.

    Los privilegios de acceso en S3 Buckets también se pueden especificar a través de la Consola de AWS, la herramienta AWS CLI o mediante las API y bibliotecas proporcionadas.

    ¿Qué es Boto3?

    Boto3 Es un kit de desarrollo de software (SDK) que proporciona AWS para la interacción con las API de S3 y otros servicios como Nube informática elástica (EC2). Con Boto3, podemos enumerar todos los buckets de S3, crear instancias EC2 o controlar cualquier cantidad de recursos de AWS.

    ¿Por qué utilizar S3?

    Siempre podemos proporcionar nuestros propios servidores para almacenar y hacer que nuestros datos sean accesibles desde una variedad de dispositivos en Internet, entonces, ¿por qué deberíamos usar S3 AWS? Hay algunos casos en los que es conveniente.

    Primero, AWS S3 elimina todo el trabajo involucrado y los costos de construir y mantener servidores que almacenan nuestros datos. No tenemos que preocuparnos por conseguir el hardware para alojar nuestros datos o el personal necesario para mantener la infraestructura. En cambio, podemos centrarnos por completo en nuestro código y asegurarnos de que nuestros servicios estén en las mejores condiciones.

    Al utilizar S3, tenemos que aprovechar las increíbles capacidades de rendimiento, disponibilidad y escalabilidad de AWS. Nuestro código podrá escalar de manera eficiente y operar bajo cargas pesadas y estará altamente disponible para nuestros usuarios finales. Debemos lograr esto sin construir o administrar la infraestructura detrás de él.

    AWS proporciona herramientas para ayudarnos con el análisis y la auditoría, así como con la administración y los informes de nuestros datos. Podemos ver y analizar cómo se accede a los datos de nuestros depósitos o incluso cómo se replican en otras regiones para mejorar el acceso del usuario final a los datos. Nuestros datos están encriptados y almacenados de forma segura para que permanezcan seguros.

    A través de AWS Lambda, también podemos responder a los datos cargados o descargados de nuestros buckets S3 y responder a los usuarios a través de alertas o informes configurados para una experiencia más personalizada e inmediata como se espera de la tecnología.

    Establecimiento de AWS

    Para comenzar con S3, necesitamos configurar una cuenta en AWS o inicie sesión en uno existente.

    También necesitaremos configurar una herramienta AWS CLI para poder interactuar con nuestros recursos desde la línea de comandos, que está disponible para Mac, Linux y Windows.

    Podemos instalarlo ejecutando:

    $ pip install awscli
    

    Una vez configurada la herramienta CLI, podemos generar nuestras credenciales en nuestro perfil desplegable y usarlas para configurar nuestra herramienta CLI de la siguiente manera:

    $ aws configure
    

    Este comando nos dará consejos para nuestro Access Key ID, Secret Access Key, regiones predeterminadas y formatos de salida. Se pueden encontrar más detalles sobre la configuración de la herramienta CLS AWS aquí.

    Nuestra aplicación – FlaskDrive

    Arreglo

    Creemos una aplicación Flask que permita a los usuarios cargar y descargar archivos desde y hacia nuestros buckets S3, alojados en AWS.

    Usaremos el SDK de Boto3 para facilitar estas operaciones y eliminar frentes simples para permitir a los usuarios cargar los archivos y verlos como alojados en línea.

    Es recomendable utilizar un entorno virtual cuando se trabaja en proyectos de Python, y para este usaremos el Pipenv una herramienta para crear y gestionar nuestro entorno. Una vez instalado, creamos y activamos nuestro entorno con Python3 de la siguiente manera:

    $ pipenv install --three
    $ pipenv shell
    

    Necesitamos instalar ahora Boto3 y Flask necesario para construir nuestra aplicación FlaskDrive de la siguiente manera:

    $ pipenv install flask
    $ pipenv install boto3
    

    Implementación

    Después de configurarlo, necesitamos crear los depósitos para almacenar nuestros datos y podemos lograrlo dirigiéndonos a la consola de AWS y S3 seleccionándolo en el menú Servicios.

    Después de crear un depósito, podemos usar la herramienta CLI para ver los depósitos que tenemos disponibles:

    $ aws s3api list-buckets
    {
        "Owner": {
            "DisplayName": "robley",
            "ID": "##########################################"
        },
        "Buckets": [
            {
                "CreationDate": "2019-09-25T10:33:40.000Z",
                "Name": "flaskdrive"
            }
        ]
    }
    

    Ahora crearemos las funciones para cargar, descargar y listar archivos en nuestros buckets S3 usando el SDK de Boto3, comenzando con el upload_file función:

    def upload_file(file_name, bucket):
        """
        Function to upload a file to an S3 bucket
        """
        object_name = file_name
        s3_client = boto3.client('s3')
        response = s3_client.upload_file(file_name, bucket, object_name)
    
        return response
    

    El es upload_file la función toma un archivo y el nombre del depósito y carga el archivo dado a nuestro depósito S3 en AWS.

    def download_file(file_name, bucket):
        """
        Function to download a given file from an S3 bucket
        """
        s3 = boto3.resource('s3')
        output = f"downloads/{file_name}"
        s3.Bucket(bucket).download_file(file_name, output)
    
        return output
    

    El es download_file la función toma un nombre de archivo y un depósito y lo descarga en una carpeta que especifiquemos.

    def list_files(bucket):
        """
        Function to list files in a given S3 bucket
        """
        s3 = boto3.client('s3')
        contents = []
        for item in s3.list_objects(Bucket=bucket)['Contents']:
            contents.append(item)
    
        return contents
    

    La función list_files Se utiliza para recuperar los archivos de nuestro depósito S3 y enumerar sus nombres. Usaremos estos nombres para descargar los archivos de nuestros depósitos de S3.

    Con nuestro archivo de interacción S3 en su lugar, podemos construir nuestra aplicación Flask para proporcionar la interfaz basada en web para la interacción. La aplicación será una simple aplicación Flask de cualquier archivo con fines de visualización con la siguiente estructura:

    .
    ├── Pipfile       # stores our application requirements
    ├── __init__.py
    ├── app.py        # our main Flask application
    ├── downloads     # folder to store our downloaded files
    ├── s3_demo.py    # S3 interaction code
    ├── templates
    │   └── storage.html
    └── uploads       # folder to store the uploaded files
    

    La funcionalidad principal de nuestra aplicación Flask residirá en el app.py archivo:

    import os
    from flask import Flask, render_template, request, redirect, send_file
    from s3_demo import list_files, download_file, upload_file
    
    app = Flask(__name__)
    UPLOAD_FOLDER = "uploads"
    BUCKET = "flaskdrive"
    
    @app.route("https://Pharos.sh.com/")
    def entry_point():
        return 'Hello World!'
    
    @app.route("/storage")
    def storage():
        contents = list_files("flaskdrive")
        return render_template('storage.html', contents=contents)
    
    @app.route("/upload", methods=['POST'])
    def upload():
        if request.method == "POST":
            f = request.files['file']
            f.save(os.path.join(UPLOAD_FOLDER, f.filename))
            upload_file(f"uploads/{f.filename}", BUCKET)
    
            return redirect("/storage")
    
    @app.route("/download/<filename>", methods=['GET'])
    def download(filename):
        if request.method == 'GET':
            output = download_file(filename, BUCKET)
    
            return send_file(output, as_attachment=True)
    
    if __name__ == '__main__':
        app.run(debug=True)
    

    Esta es una aplicación Flask simple con 4 puntos finales:

    • El es /storage es el punto final de la página de destino donde mostraremos los archivos actuales en nuestro depósito S3 para descargar, y también la entrada para que los usuarios carguen archivos en nuestro depósito S3,
    • El es /upload se utilizará un punto final para recuperar un archivo y luego llamar al upload_file() método que carga un archivo en un depósito de S3
    • El es /download endpoint encontrará un nombre de archivo y usará el download_file() método para descargar el archivo al dispositivo del usuario

    Y finalmente, nuestra plantilla HTML será tan simple como:

    <!DOCTYPE html>
    <html>
      <head>
        <title>FlaskDrive</title>
      </head>
      <body>
        <div class="content">
            <h2>Flask Drive: S3 Flask Demo</h2>
            <p>Welcome to this AWS S3 Demo</p>
            <div>
              <h2>Upload your file here:</h2>
              <form method="POST" action="/upload" enctype=multipart/form-data>
                <input type=file name=file>
                <input type=submit value=Upload>
              </form>
            </div>
            <div>
              <h2>These are your uploaded files:</h2>
              <p>Click on the filename to download it.</p>
              <ul>
                {% for item in contents %}
                  <li>
                    <a href="/download/{{ item.Key }}"> {{ item.Key }} </a>
                  </li>
                {% endfor %}
              </ul>
            </div>
        </div>
      </body>
    </html>
    

    Una vez que nuestro código y carpetas están configurados, iniciamos nuestra aplicación con:

    $ python app.py
    

    Cuando navegamos a http://localhost:5000/storage damos la bienvenida a la siguiente página de destino:

    Ahora carguemos un archivo usando el campo de entrada y aquí está la salida:

    Podemos confirmar la carga comprobando nuestro panel de S3, y luego podemos obtener nuestra imagen:

    Nuestro archivo se cargó correctamente desde nuestra máquina a S3 AWS Storage.

    En nuestra página de inicio de FlaskDrive, podemos descargar el archivo simplemente haciendo clic en el nombre del archivo y luego aparece el mensaje para guardar el archivo en nuestras máquinas.

    Conclusión

    En esta publicación, hemos creado una aplicación Flask que almacena archivos en el S3 de AWS y nos permite descargar los mismos archivos desde nuestra aplicación. Usamos la biblioteca Boto3 junto con la herramienta CLS AWS para manejar la interacción entre nuestra aplicación y AWS.

    Eliminamos la necesidad de tener nuestros propios servidores para manejar el almacenamiento de nuestros archivos y aprovechar la infraestructura de Amazon para manejarlo por nosotros a través del AWS Simple Storage Service. Nos tomó un tiempo desarrollar, implementar y poner nuestra aplicación a disposición de los usuarios finales y ahora podemos mejorarla para agregar permisos entre otras funciones.

    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 *