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

I

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

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

By Ramiro de la Vega

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con tus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad