Cargue archivos a AWS S3 con Python y Django

     

    Introducción

    A medida que buscamos construir sitios web más interactivos, no solo proporcionamos información a los usuarios, sino que también les permitimos cargar sus propios datos. Esto abre más oportunidades y más formas en que nuestros sitios web pueden servir a los usuarios finales.

    Al permitir que los usuarios carguen archivos, podemos permitirles compartir fotos, videos o música con otros o hacer copias de seguridad de ellos para su custodia. También podemos proporcionar la funcionalidad para administrar archivos y convertirlos a otros formatos instalando sitios web en lugar de aplicaciones nativas.

    El auge de las redes sociales en todo el mundo se puede atribuir a la capacidad de los usuarios para cargar sus archivos, principalmente en forma de imágenes y videos para que otros usuarios los vean y también como medio de comunicación. Al permitir que los usuarios carguen archivos en sitios web y plataformas, se han mejorado los métodos de comunicación y ahora la información se puede difundir en muchos formatos diferentes.

    En esta publicación, exploraremos cómo Django maneja la carga de archivos y cómo podemos aprovechar esta funcionalidad y expandir el almacenamiento en la nube para satisfacer nuestras necesidades.

    Cómo maneja Django el almacenamiento de archivos

    Django no solo nos permite convertir conceptos en aplicaciones web, sino que también nos brinda la funcionalidad de manejar archivos y permitir que los usuarios carguen archivos en nuestras aplicaciones web para una mayor interacción. A través de formularios, los usuarios pueden adjuntar archivos a sus aplicaciones y cargar y almacenar sus archivos en nuestros servidores postdoctorales.

    Antes de que se guarde un archivo, se almacena temporalmente en algún lugar antes de procesarse y almacenarse en el lugar final previsto. Por ejemplo, si el archivo cargado tiene menos de 2,5 MB, el contenido de ese archivo se almacenará en la memoria y luego se escribirá en el disco cuando se completen todas las operaciones mientras se procesa.

    Esto acelera el proceso para archivos pequeños. Para archivos de más de 2,5 MB, primero se escriben en una ubicación temporal a medida que se reciben los datos, luego, cuando se completa el procesamiento, el archivo se transfiere a su destino final.

    El transporte de archivos en Django se puede personalizar a través de varias configuraciones, por ejemplo FILE_UPLOAD_MAX_MEMORY_SIZE, que nos permite modificar un tamaño límite de carga de 2,5 MB para los archivos escritos en la memoria primero y no en una ubicación temporal. Podemos configurar los permisos predeterminados para los archivos cargados a través de FILE_UPLOAD_PERMISSIONS.

    Otras configuraciones se pueden encontrar en esta parte de la documentación oficial de Django.

    ¿Dónde podemos almacenar nuestros archivos?

    En una aplicación web impulsada por Django, podemos almacenar los archivos cargados en diferentes ubicaciones. Podemos almacenarlos en nuestros propios servidores donde se usa el código de Django, o podemos enviarlos a otros servidores que pueden haber sido configurados en otro lugar con fines de almacenamiento.

    En un esfuerzo por reducir los costos de mantenimiento del servidor y mejorar el rendimiento, también podemos optar por no almacenar los archivos cargados en nuestros propios servidores. En este caso, podemos dárselos a otros proveedores de almacenamiento alojado como AWS, Azuro OneDrive, entre otros.

    Existen varios paquetes que nos permiten interactuar con las API proporcionadas por los distintos proveedores de servicios que hemos mencionado. Éstas incluyen:

    Para esta publicación, usaremos el Django-s3direct paquete para almacenar nuestros archivos en AWS S3.

    Nuestra aplicación – Django Drive

    Usaremos Django para crear una aplicación web en la que cargaremos contenido para que lo vean los usuarios finales. Esto se logrará mediante el uso de la interfaz de administración de Django, que es compatible con el marco.

    Nuestro sitio se utilizará para vender autos y en él mostraremos detalles y publicaremos imágenes o videos de los autos a la venta.

    Las imágenes o videos de autos a la venta se almacenarán en S3. No aplicaremos el registro de usuario o el inicio de sesión en este momento por motivos de precisión.

    Arreglo

    Usaremos Pipenv para configurar y administrar nuestro entorno remoto en el que construimos nuestra aplicación Django ejecutando el siguiente comando para configurarlo usando Python3:

    $ pipenv install --three
    

    Una vez que el entorno está configurado, ahora podemos instalarlo Django y Django-s3direct para manejar nuestra carga de archivos a S3:

    $ pipenv install django django-s3direct
    

    Django proporciona un conjunto de comandos para configurar nuestro proyecto antes de comenzar a implementar la funcionalidad principal de nuestra aplicación. Nuestro proyecto de conducción de Django tendrá una aplicación que será el foco de este trabajo. Para lograr esto, ejecutamos los siguientes comandos:

    $ django-admin startproject django_drive && cd django_drive
    $ django-admin startapp django_drive_app
    

    El es django-admin startproject ... la orden crea el proyecto, y el django-admin startapp ... comando crea la aplicación.

    El último paso en nuestra configuración es crear tablas de base de datos a través de la migrate orden:

    $ python manage.py migrate
    

    Cuando comenzamos nuestro proyecto ejecutando el líder python manage.py runserver, damos la bienvenida a la siguiente página, que confirma el éxito de nuestro acuerdo:

    Dado que cargaremos nuestros archivos en AWS S3, necesitaremos configurar una capa libre Cuenta de AWS con fines de demostración. Una vez configurados, podemos navegar hasta el panel S3 y crear un nuevo depósito que contenga nuestras cargas.

    por Django-s3direct para interactuar con nuestra configuración de AWS, debemos proporcionar las siguientes credenciales AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, y el AWS_STORAGE_BUCKET_NAME.

    Luego agregaremos lo siguiente a nuestro django_drive/settings.py archivo:

    AWS_ACCESS_KEY_ID = 'aws-access-key-id'
    AWS_SECRET_ACCESS_KEY = 'secret-access-key'
    AWS_STORAGE_BUCKET_NAME = 'name-of-the-bucket'
    AWS_S3_REGION_NAME = 'name-of-the-region'
    AWS_S3_ENDPOINT_URL = 'https://s3.amazonaws.com'
    
    S3DIRECT_DESTINATIONS = {
        'primary_destination': {
            'key': 'uploads/',
            'allowed': ['image/jpg', 'image/jpeg', 'image/png', 'video/mp4'],
        },
    }
    

    Django-s3direct nos permite especificar más de un destino para nuestras cargas, de esta manera podemos dirigir varios archivos a depósitos de S3 separados. Para este proyecto, pondremos todas las cargas en un solo depósito. Otra característica ingeniosa es que podemos limitar los tipos de archivos que se pueden cargar en nuestro sitio web. En nuestro caso, estamos limitados a videos MP4, JPEG e imágenes PNG únicamente.

    Nota: Más detalles sobre la configuración Django-s3direct, como CORS y Access Setup, están disponibles aquí.

    Necesitamos agregar las siguientes entradas en el django_drive/urls.py archivo:

    from django.urls import path, include
    
    urlpatterns = [
        ...
        path('', include('django_drive_app.urls')),
        path('s3direct/', include('s3direct.urls')),
        ...
    ]
    

    Implementación

    Comenzaremos creando el modelo para los datos de nuestro automóvil, que se mostrará a los usuarios finales. Este modelo definirá la información que agregaremos a nuestro panel de administración al agregar autos a nuestra plataforma. El modelo del coche es el siguiente:

    from django.db import models
    from s3direct.fields import S3DirectField
    
    class Car(models.Model):
        name = models.CharField(max_length=255, blank=False, null=False)
        year_of_manufacture = models.CharField(max_length=255, blank=False, null=False)
        price = models.CharField(max_length=255, blank=False, null=False)
        image = S3DirectField(dest="primary_destination", blank=True)
        video = S3DirectField(dest="primary_destination", blank=True)
    
        def __str__(self):
            return f"{self.name} ({self.year_of_manufacture}) - {self.price}"
    

    Para cada automóvil, almacenamos su nombre, año de fabricación, precio e imagen o video. Después de crear el modelo, migremos para crear la tabla en la base de datos que contendrá nuestros datos ejecutando:

    $ python manage.py makemigrations
    $ python manage.py migrate
    

    Dado que usaremos el panel de administración de Django para administrar los autos en nuestra plataforma, necesitamos registrar nuestro modelo en el django_drive_app/admin.py:

    from django.contrib import admin
    from.models import Car
    
    admin.site.register(Car)
    

    Luego necesitamos crear el superusuario que se encargará de agregar los autos ejecutando el siguiente comando y siguiendo los consejos:

    $ python manage.py createsuperuser
    $ python manage.py runserver
    

    El es python manage.py runserver el comando simplemente reinicia nuestra aplicación.

    Después de reiniciar nuestro servidor, ahora podemos navegar al panel de administración en http://127.0.0.1:8000/admin e inicie sesión con las credenciales que especificamos anteriormente. Bajo la administración del sitio, podemos DJANGO_DRIVE_APP con la opción de agregar o cambiar autos existentes.

    Aquí está el formulario que usamos para agregar un automóvil y sus detalles:

    Una vez que guardemos nuestro automóvil, podemos obtener la imagen que cargamos en nuestro bucket de S3 en una consola de AWS. Esto significa que nuestro archivo se cargó en AWS.

    Ahora crearemos una vista para mostrar los autos y sus detalles a los usuarios finales de nuestro sitio web y también mostraremos las imágenes o videos relacionados con cada auto. Empezaremos creando una escena en el django_drive_app/views.py:

    from django.shortcuts import render
    from django.views.generic import TemplateView
    from .models import Car
    
    class CarView(TemplateView):
        template_name="django_drive_app/cars.html"
    
        def get_context_data(self, **kwargs):
            context = super().get_context_data(**kwargs)
            context['cars'] = Car.objects.all()
            return context
    

    En esta vista, usamos un vista de Django basada en clases para proporcionar el archivo HTML para mostrar nuestros coches. En nuestra opinión, estamos realizando una consulta para encontrar todos los coches almacenados en nuestra base de datos.

    A continuación, demostrémoslo django_drive_app/templates/django_drive_app/cars.html para traer nuestros coches:

    <!DOCTYPE html>
    <html>
      <head>
        <title>Django Drive</title>
      </head>
      <body>
        <h2>Welcome to Django Drive. </h2>
        <p>Here are the current cars available for sale: </p>
        <div class="cars-container">
          {% for car in cars %}
            <div class="car">
              <p>
                <b> {{ car.name }} ({{ car.year_of_manufacture }}) </b> <br>
                Price: {{ car.price }}
              </p>
              <!-- if the car has an image attached -->
              {% if car.image %}
              <img src="{{ car.image }}" height="200" width="400"/>
              {% endif %}
              <!-- If the car has a video -->
              {% if car.video %}
                <video width="320" height="240" controls>
                    <source src="{{ car.video }}" type="video/mp4">
                  Your browser does not support the video tag.
                </video>
              {% endif %}
            </div>
            <hr>
          {% endfor %}
        </div>
      </body>
    </html>
    

    Con la escena y la plantilla en su lugar, veamos el punto final que se utilizará para mostrar la lista de automóviles a los usuarios finales a través de la django_drive_app/urls.py:

    from django.conf.urls import url
    from .views import CarView
    
    urlpatterns = [
      url(r'^cars/$', CarView.as_view(), name="cars"),
    ]
    

    Importamos nuestra vista y agregamos una entrada de URL para mapear el punto final a la vista que darán los autos. Cuando reiniciamos nuestro servidor y navegamos a 127.0.0.1:8000/cars/, llegamos a lo siguiente:

    Como podemos ver, creamos autos con imágenes y videos adjuntos y los subimos al servicio S3 AWS. Las mismas imágenes y videos se realizaron en nuestra aplicación web después de recibirlos de AWS.

    Conclusión

    En este artículo, hemos creado una aplicación Django simple que permite a los administradores cargar archivos a AWS S3 a través del panel de administración de Django. Colocamos los archivos cargados alojados en S3 en nuestra página de destino, incluidos videos e imágenes de los autos que los usuarios desean comprar o ver.

    Solíamos Django-s3direct una biblioteca para manejar la interacción entre nuestras aplicaciones Django y AWS S3 en las que se almacenan nuestros archivos. A través de la aplicación de administración de Django, finalmente pudimos entregar archivos a los usuarios finales en nuestra página de destino. Pudimos subir y proporcionar imágenes y videos.

    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 *