Implementación de aplicaciones de Django en AWS EC2 con Docker

    Introducción

    En el acelerado campo de las aplicaciones web, la contenedorización se ha convertido no solo en algo común, sino en el modo preferido de empaquetar y entregar aplicaciones web. Los contenedores nos permiten empaquetar nuestras aplicaciones e implementarlas en cualquier lugar sin tener que reconfigurar o adaptar nuestras aplicaciones a la plataforma de implementación.

    A la vanguardia de la contenerización está Estibador, que es una herramienta que se utiliza para empaquetar y ejecutar aplicaciones en contenedores que son independientes de la plataforma. La tecnología sin servidor también está floreciendo en esta era de contenedorización y está demostrando ser la opción preferida para los desarrolladores cuando implementan sus aplicaciones con más y más proveedores que permiten a los usuarios implementar software en contenedores.

    Si bien la creación de una aplicación es importante, ponerla a disposición de los usuarios finales también es una parte crucial del producto. En esta publicación, empaquetaremos una aplicación Django usando Docker y la implementaremos en EC2 de Amazon.

    ¿Qué es EC2?

    De Amazon Nube informática elástica (EC2) es una oferta que permite a los desarrolladores aprovisionar y ejecutar sus aplicaciones creando instancias de máquinas virtuales en la nube. EC2 también ofrece escalado automático donde los recursos se asignan en función de la cantidad de tráfico recibido.

    Al igual que cualquier otra oferta de AWS, EC2 se puede integrar fácilmente con los otros servicios de Amazon, como el Servicio de cola simple (SQS), o Simple Storage Service (S3), entre otros.

    EC2 tiene las siguientes características:

    • Instancias: Entornos o servidores informáticos virtuales que permiten a los desarrolladores ejecutar sus aplicaciones. Estas instancias se pueden configurar en términos de memoria, almacenamiento, potencia informática y recursos de red para adaptarse a la necesidad o escenario actual.
    • Imágenes de la máquina de Amazon (AMI): plantillas preconfiguradas que se utilizan para crear instancias. Vienen con sistemas operativos y software precargado según sea necesario y son personalizables.
    • Volúmenes de almacén de instancias: Se utiliza para almacenar datos temporalmente. Estos datos se eliminan cuando se termina la instancia.
    • Tienda de bloques elásticos (EBS) Volúmenes: volúmenes de almacenamiento confiables y de alta disponibilidad que se adjuntan a instancias con el fin de almacenar datos de manera persistente. Los datos almacenados en EBS Volumes sobreviven a las instancias y se pueden montar varios volúmenes en una instancia.
    • Grupos de seguridad: Firewalls virtuales que gobiernan el acceso a las instancias especificando protocolos, rangos de direcciones IP y puertos. Esto nos permite controlar y restringir el tráfico a nuestras instancias.

    Estas son solo algunas de las características de Elastic Compute Cloud de Amazon y se pueden encontrar más en la documentación.

    Prerrequisitos

    En este tutorial, crearemos una aplicación web y la implementaremos en el servicio EC2 de Amazon. Para lograr eso necesitamos:

    • Un Servicios web de Amazon (AWS) que nos dará acceso a EC2. Mediante este enlace, puede registrarse en el nivel gratuito que es suficiente para el trabajo en esta publicación.
    • Python 3.6+, Pip y Virtualenv instalado para construir nuestra aplicación Django.
    • Estibador También será necesario empaquetar nuestra aplicación y ejecutarla fácilmente en un contenedor que no solo sea portátil, sino que pueda ejecutarse en cualquier lugar donde esté instalado Docker.

    Dockerizar una aplicación Django

    Comenzaremos construyendo nuestra sencilla aplicación Django y colocándola en contenedores para permitirnos implementarla fácilmente. Comencemos creando una carpeta para nuestro proyecto:

    $ mkdir django_ec2 && cd $_
    

    Luego un entorno virtual:

    $ virtualev --python=python3 env --no-site-packages
    

    Entonces, activémoslo e instalemos Django:

    $ source env/bin/activate
    $ pip install Django
    

    Una simple aplicación Django de marcador de posición será suficiente. Todo lo que tenemos que hacer para arrancar el proyecto es ejecutar django-admines startproject comando, que inicia un proyecto básico para el nombre de directorio dado:

    $ django-admin startproject django_ec2_project
    

    Luego, ingresemos al directorio del proyecto:

    $ cd django_ec2_project
    

    E inicie un servidor de desarrollo ligero:

    $ python manage.py runserver
    

    Si todo va bien, deberíamos poder ver la siguiente página de destino cuando accedamos a nuestra aplicación en localhost:8000:

    Antes de empaquetar nuestra aplicación Django, debemos permitir el tráfico a todas las fuentes, lo que podemos lograr modificando el ALLOWED_HOSTS instalándose django_ec2_project/django_ec2_project/settings.py:

    # Add the asterisk in the empty list
    ALLOWED_HOSTS = ['*']
    

    Nota: No es recomendable dejar un comodín en un entorno de producción. Utilice el dominio de su propio sitio de producción en lugar de este.

    Dado que esto es suficiente para ser implementado, sigamos adelante y organicemos nuestra aplicación en contenedores agregando un Dockerfile en la raíz de nuestro proyecto que contiene lo siguiente:

    FROM python:3.6-alpine
    
    MAINTAINER Robley Gori <ro6ley.github.io>
    
    EXPOSE 8000
    
    RUN apk add --no-cache gcc python3-dev musl-dev
    
    ADD . /django_ec2
    
    WORKDIR /django_ec2
    
    RUN pip install -r requirements.txt
    
    RUN python django_ec2_project/manage.py makemigrations
    
    RUN python django_ec2_project/manage.py migrate
    
    CMD [ "python", "django_ec2_project/manage.py", "runserver", "0.0.0.0:8000" ]
    

    Este Dockerfile describe cómo se colocará en contenedores y se ejecutará nuestra aplicación. En la parte superior, usamos una imagen base que viene con Python 3.6 instalado. También exponemos el puerto 8000, lo que significa que el tráfico hacia el contenedor debe dirigirse a ese puerto, que es también desde donde se ejecutará nuestra aplicación Django. Instalamos algunos paquetes en nuestra imagen y luego agregamos nuestra aplicación Django al django_ec2 directorio.

    Dado que nuestro proyecto Django está en contenedores, no necesitaremos crear un entorno virtual ya que ya está aislado de la máquina que lo ejecutará. Por lo tanto, instalamos los requisitos directamente y ejecutamos las migraciones.

    Al final, agregamos el comando que se ejecutará cuando se inicie el contenedor, que en nuestro caso también iniciará nuestra aplicación Django y la ejecutará en el puerto 8000.

    Si desea una explicación más detallada sobre este tema, consulte nuestro artículo Dockerizing Python Applications.

    El siguiente paso será crear nuestra imagen de Docker usando el Dockerfile anterior. Antes de eso, guardaremos las dependencias instaladas en el entorno en un archivo:

    $ pip freeze > requirements.txt
    

    Y solo entonces, construyamos la imagen de la ventana acoplable:

    $ docker build . -t django_ec2
    

    Mediante este comando, Docker buscará nuestro Dockerfile en la carpeta actual y lo usará para construir una imagen, que será etiquetada como django_ec2. Una vez que nuestra imagen está construida, podemos ejecutarla usando el comando:

    $ docker run -d -p 8000:8000 django_ec2
    

    Este comando iniciará nuestro contenedor que tiene nuestra aplicación Django en ejecución y mapeará el puerto 8000 en nuestra máquina al puerto del contenedor 8000, según lo especificado por el -p bandera y se ejecutará sin cabeza (incluso después de cerrar la terminal) según lo especificado por el -d bandera.

    Deberíamos ser recibidos por la misma página de destino de Django cuando navegamos a localhost:8000 una vez más, solo que esta vez estaremos accediendo a la aplicación en el contenedor Docker en lugar de a la de nuestra máquina local.

    Con nuestra imagen lista, necesitamos publicarla en Dockerhub para facilitar el proceso de implementación en EC2.

    Dockerhub es un registro de imágenes listas para usar que permite a los usuarios crear y compartir imágenes personalizadas de Docker para todos los propósitos. También nos permite publicar nuestras imágenes para poder acceder a ellas en otras plataformas como AWS. En nuestro caso, publicaremos nuestra imagen en Dockerhub y luego la colocaremos en EC2 para su implementación.

    Para publicar nuestra imagen, necesitamos crea una cuenta en Dockerhub primero e inicie sesión en nuestro terminal:

    $ docker login
    

    Una vez que haya iniciado sesión, necesitaremos etiquetar nuestra imagen con nuestro nombre de usuario y luego enviarla a Dockerhub:

    $ docker tag django_ec2 <DOCKERHUB_USERNAME>/django_ec2
    $ docker push <DOCKERHUB_USERNAME>/django_ec2
    

    Con esto, estamos listos para el siguiente paso, que es implementar nuestra aplicación en Elastic Compute Cloud de Amazon.

    Implementación en EC2

    Con nuestra imagen de Docker lista y publicada en Dockerhub, ahora podemos iniciar sesión en la consola de nuestra cuenta de AWS y en el Panel de control EC2, podemos crear una nueva instancia, lo que se logra mediante una serie de pasos.

    Elija la AMI

    El primer paso consiste en seleccionar una imagen de máquina de Amazon (AMI) que se utilizará para crear nuestra instancia. Se nos presentan opciones que incluyen Red Hat, Ubuntu Server y Windows Server.

    Para esta demostración, necesitaremos una imagen personalizada para ejecutar contenedores y barcos con Docker. Para encontrarlo, escriba ECS en la barra de búsqueda:

    El Amazon Linux 2 optimizado para Amazon ECS es ideal para nuestro escenario y es el que elegiremos.

    Elija el tipo de instancia

    Después de elegir la AMI para nuestra instancia, ahora tenemos que elegir un tipo de instancia. Nuestra elección aquí dictará la cantidad de recursos que tendrá nuestra instancia en términos de CPU, memoria, almacenamiento y capacidad de rendimiento de la red.

    Dado que estamos en la capa gratuita de AWS, seguiremos adelante y utilizaremos la t2.micro instancia, que está pensada para instancias de uso general y viene con 1 CPU virtual y 1 GiB de memoria.

    La lista contiene tipos de instancias más potentes y otras están optimizadas para potencia informática, memoria o almacenamiento.

    Configurar instancia

    Ahora que hemos elegido el tipo de instancia, el siguiente paso nos permite especificar algunos detalles más sobre nuestra instancia, incluida la cantidad de instancias que se lanzarán en un momento dado, opciones de red y sistemas de archivos, entre otros detalles. No realizaremos ningún cambio en las opciones predeterminadas en este paso.

    Agregar almacenamiento

    El cuarto paso consiste en agregar y especificar los detalles de almacenamiento para nuestra instancia. Esta sección nos permite agregar volúm

    Rate this post
    Etiquetas: