Aprenda a crear e implementar sus aplicaciones distribuidas fácilmente en la nube con Docker-2
Imágenes de Docker
Hemos visto imágenes antes, pero en esta sección profundizaremos en qué son las imágenes de Docker y crearemos nuestra propia imagen. Por último, también usaremos esa imagen para ejecutar nuestra aplicación localmente y finalmente implementarla en AWS para compartirla con nuestros amigos. ¿Entusiasmado? ¡Excelente! Empecemos.
Las imágenes de Docker son la base de los contenedores. En el ejemplo anterior, extrajimos la imagen de Busybox del registro y le pedimos al cliente Docker que ejecutara un contenedor basado en esa imagen. Para ver la lista de imágenes que están disponibles localmente, use el docker imagescomando.
$ docker images REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE prakhar1989/catnip latest c7ffb5626a50 2 hours ago 697.9 MB prakhar1989/static-site latest b270625a1631 21 hours ago 133.9 MB python 3-onbuild cf4002b2c383 5 days ago 688.8 MB martin/docker-cleanup-volumes latest b42990daaca2 7 weeks ago 22.14 MB ubuntu latest e9ae3c220b23 7 weeks ago 187.9 MB busybox latest c51f86c28340 9 weeks ago 1.109 MB hello-world latest 0a6ba66e537a 11 weeks ago 960 B
Lo anterior proporciona una lista de imágenes que saqué del registro, junto con las que creé yo mismo (veremos cómo en breve). Se TAGrefiere a una instantánea particular de la imagen y IMAGE IDes el identificador único correspondiente para esa imagen.
Para simplificar, puede pensar en una imagen similar a un repositorio git: las imágenes se pueden confirmar con cambios y tener múltiples versiones. Si no proporciona un número de versión específico, el cliente utiliza de forma predeterminada latest. Por ejemplo, puedes extraer una versión específica de ubuntula imagen.
$ docker pull ubuntu:18.04
Para obtener una nueva imagen de Docker, puede obtenerla de un registro (como Docker Hub) o crear una propia. Hay decenas de miles de imágenes disponibles en Docker Hub . También puedes buscar imágenes directamente desde la línea de comando usando docker search.
Una distinción importante a tener en cuenta cuando se trata de imágenes es la diferencia entre imágenes base e imágenes secundarias.
- Las imágenes base son imágenes que no tienen una imagen principal, generalmente imágenes con un sistema operativo como Ubuntu, Busybox o Debian.
- Las imágenes secundarias son imágenes que se basan en imágenes base y agregan funcionalidad adicional.
Luego están las imágenes oficiales y de usuario, que pueden ser tanto imágenes base como secundarias.
- Las imágenes oficiales son imágenes mantenidas y respaldadas oficialmente por la gente de Docker. Por lo general, tienen una longitud de una palabra. En la lista de imágenes de arriba, las
pythonimágenesubuntu,busyboxyhello-worldson imágenes oficiales. - Las imágenes de usuario son imágenes creadas y compartidas por usuarios como tú y como yo. Se basan en imágenes base y agregan funcionalidad adicional. Normalmente, estos tienen el formato
user/image-name.
Nuestra primera imagen
Ahora que comprendemos mejor las imágenes, es hora de crear las nuestras. Nuestro objetivo en esta sección será crear una imagen que guarde en un espacio aislado una aplicación Flask simple . Para los propósitos de este taller, ya he creado una pequeña y divertida aplicación Flask que muestra un gato al azar .gifcada vez que se carga, porque ya sabes, ¿a quién no le gustan los gatos? Si aún no lo has hecho, continúa y clona el repositorio localmente de esta manera:
$ git clone https://github.com/prakhar1989/docker-curriculum.git $ cd docker-curriculum/flask-app
Esto debe clonarse en la máquina donde ejecuta los comandos de la ventana acoplable y no dentro de un contenedor de la ventana acoplable.
El siguiente paso ahora es crear una imagen con esta aplicación web. Como se mencionó anteriormente, todas las imágenes de usuario se basan en una imagen base. Dado que nuestra aplicación está escrita en Python, la imagen base que usaremos será Python 3 .
archivo acoplable
Un Dockerfile es un archivo de texto simple que contiene una lista de comandos que el cliente Docker llama mientras crea una imagen. Es una forma sencilla de automatizar el proceso de creación de imágenes. La mejor parte es que los comandos que escribe en un Dockerfile son casi idénticos a sus comandos equivalentes de Linux. Esto significa que realmente no es necesario aprender una nueva sintaxis para crear sus propios archivos acoplables.
El directorio de la aplicación contiene un Dockerfile pero como lo hacemos por primera vez, crearemos uno desde cero. Para comenzar, cree un nuevo archivo en blanco en nuestro editor de texto favorito y guárdelo en la misma carpeta que la aplicación flask con el nombre de Dockerfile.
Comenzamos especificando nuestra imagen base. Utilice la FROMpalabra clave para hacer eso:
FROM python:3.8
El siguiente paso suele ser escribir los comandos para copiar los archivos e instalar las dependencias. Primero, configuramos un directorio de trabajo y luego copiamos todos los archivos de nuestra aplicación.
# set a directory for the app WORKDIR /usr/src/app # copy all the files to the container COPY . .
Ahora que tenemos los archivos, podemos instalar las dependencias.
# install dependencies RUN pip install --no-cache-dir -r requirements.txt
Lo siguiente que debemos especificar es el número de puerto que debe exponerse. Dado que nuestra aplicación flask se ejecuta en el puerto 5000, eso es lo que indicaremos.
EXPOSE 5000
El último paso es escribir el comando para ejecutar la aplicación, que es simplemente - python ./app.py. Usamos el comando CMD para hacer eso:
CMD ["python", "./app.py"]
El objetivo principal de CMDes indicarle al contenedor qué comando debe ejecutar cuando se inicia. Con eso, nuestro Dockerfileya está listo. Así es como se ve -
FROM python:3.8 # set a directory for the app WORKDIR /usr/src/app # copy all the files to the container COPY . . # install dependencies RUN pip install --no-cache-dir -r requirements.txt # define the port number the container should expose EXPOSE 5000 # run the command CMD ["python", "./app.py"]
Ahora que tenemos nuestro Dockerfile, podemos construir nuestra imagen. El docker buildcomando hace el trabajo pesado de crear una imagen de Docker a partir de un archivo Dockerfile.
La siguiente sección le muestra el resultado de ejecutar el mismo. Antes de ejecutar el comando usted mismo (no olvide el punto), asegúrese de reemplazar mi nombre de usuario por el suyo. Este nombre de usuario debe ser el mismo que creó cuando se registró en Docker Hub . Si aún no lo ha hecho, continúe y cree una cuenta. El docker buildcomando es bastante simple: toma un nombre de etiqueta opcional -ty una ubicación del directorio que contiene el archivo Dockerfile.
$ docker build -t yourusername/catnip . Sending build context to Docker daemon 8.704 kB Step 1 : FROM python:3.8 # Executing 3 build triggers... Step 1 : COPY requirements.txt /usr/src/app/ ---> Using cache Step 1 : RUN pip install --no-cache-dir -r requirements.txt ---> Using cache Step 1 : COPY . /usr/src/app ---> 1d61f639ef9e Removing intermediate container 4de6ddf5528c Step 2 : EXPOSE 5000 ---> Running in 12cfcf6d67ee ---> f423c2f179d1 Removing intermediate container 12cfcf6d67ee Step 3 : CMD python ./app.py ---> Running in f01401a5ace9 ---> 13e87ed1fbc2 Removing intermediate container f01401a5ace9 Successfully built 13e87ed1fbc2
Si no tiene la python:3.8imagen, el cliente primero la extraerá y luego la creará. Por lo tanto, su resultado al ejecutar el comando será diferente al mío. Si todo salió bien, ¡tu imagen debería estar lista! Ejecute docker imagesy vea si se muestra su imagen.
El último paso en esta sección es ejecutar la imagen y ver si realmente funciona (reemplazando mi nombre de usuario por el suyo).
$ docker run -p 8888:5000 yourusername/catnip * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
El comando que acabamos de ejecutar utilizó el puerto 5000 para el servidor dentro del contenedor y lo expuso externamente en el puerto 8888. Dirígete a la URL con el puerto 8888, donde debería estar activa tu aplicación.
¡Felicidades! Ha creado con éxito su primera imagen acoplable.
Docker en AWS
¿De qué sirve una aplicación que no se puede compartir con amigos, verdad? Entonces, en esta sección veremos cómo podemos implementar nuestra increíble aplicación en la nube para poder compartirla con nuestros amigos. Usaremos AWS Elastic Beanstalk para poner en funcionamiento nuestra aplicación con unos pocos clics. ¡También veremos lo fácil que es hacer que nuestra aplicación sea escalable y manejable con Beanstalk!
Empuje de ventana acoplable
Lo primero que debemos hacer antes de implementar nuestra aplicación en AWS es publicar nuestra imagen en un registro al que AWS pueda acceder. Hay muchos registros Docker diferentes que puedes usar (incluso puedes alojar el tuyo propio ). Por ahora, usemos Docker Hub para publicar la imagen.
Si es la primera vez que publica una imagen, el cliente le pedirá que inicie sesión. Proporcione las mismas credenciales que utilizó para iniciar sesión en Docker Hub.
$ docker login Login in with your Docker ID to push and pull images from Docker Hub. If you do not have a Docker ID, head over to https://hub.docker.com to create one. Username: yourusername Password: WARNING! Your password will be stored unencrypted in /Users/yourusername/.docker/config.json Configure a credential helper to remove this warning. See https://docs.docker.com/engine/reference/commandline/login/credential-store Login Succeeded
Para publicar, simplemente escriba el siguiente comando y recuerde reemplazar el nombre de la etiqueta de imagen de arriba con el suyo. Es importante tener el formato de yourusername/image_namepara que el cliente sepa dónde publicar.
$ docker push yourusername/catnip
Una vez hecho esto, podrá ver su imagen en Docker Hub. Por ejemplo, aquí está la página web de mi imagen.
Nota: Una cosa que me gustaría aclarar antes de continuar es que no es imperativo alojar su imagen en un registro público (o cualquier registro) para poder implementarla en AWS. En caso de que estés escribiendo código para la próxima startup unicornio de un millón de dólares, puedes saltarte este paso por completo. La razón por la que publicamos nuestras imágenes es que hace que la implementación sea muy simple al omitir algunos pasos de configuración intermedios.
Ahora que su imagen está en línea, cualquiera que tenga Docker instalado puede jugar con su aplicación escribiendo un solo comando.
$ docker run -p 8888:5000 yourusername/catnip
Si se ha tirado de los pelos al configurar entornos de desarrollo locales/compartir la configuración de aplicaciones en el pasado, sabe muy bien lo maravilloso que suena esto. ¡Es por eso que Docker es tan genial!
tallo de habichuelas
AWS Elastic Beanstalk (EB) es una PaaS (plataforma como servicio) ofrecida por AWS. Si ha utilizado Heroku, Google App Engine, etc., se sentirá como en casa. Como desarrollador, usted simplemente le dice a EB cómo ejecutar su aplicación y él se encarga del resto, incluido el escalado, el monitoreo e incluso las actualizaciones. En abril de 2014, EB agregó soporte para ejecutar implementaciones Docker de un solo contenedor, que es lo que usaremos para implementar nuestra aplicación. Aunque EB tiene una CLI muy intuitiva , requiere cierta configuración y, para simplificar las cosas, usaremos la interfaz de usuario web para iniciar nuestra aplicación.
Para seguir adelante, necesita una cuenta de AWS que funcione . Si aún no lo ha hecho, continúe y hágalo ahora; deberá ingresar la información de su tarjeta de crédito. ¡Pero no te preocupes, es gratis y todo lo que hagamos en este tutorial también será gratis! Empecemos.
- Inicie sesión en su consola de AWS .
- Haga clic en Elastic Beanstalk. Estará en la sección de cálculo en la parte superior izquierda. Alternativamente, puede acceder a la consola de Elastic Beanstalk .
- Haga clic en "Crear nueva aplicación" en la parte superior derecha
- Asigne a su aplicación un nombre memorable (pero único) y proporcione una descripción (opcional)
- En la pantalla Nuevo entorno , cree un nuevo entorno y elija el entorno del servidor web .
- Complete la información del entorno eligiendo un dominio. Esta URL es la que compartirás con tus amigos, así que asegúrate de que sea fácil de recordar.
- En la sección de configuración base. Elija Docker en la plataforma predefinida .
- Ahora necesitamos cargar el código de nuestra aplicación. Pero como nuestra aplicación está empaquetada en un contenedor Docker, solo necesitamos informarle a EB sobre nuestro contenedor. Abra el
Dockerrun.aws.jsonarchivo ubicado en laflask-appcarpeta y edite laNameimagen con el nombre de su imagen. No te preocupes, te explicaré el contenido del archivo en breve. Cuando haya terminado, haga clic en el botón de opción "Cargar su código", elija este archivo y haga clic en "Cargar". - Ahora haga clic en "Crear entorno". La pantalla final que verá tendrá algunos controles giratorios que indicarán que se está configurando su entorno. La primera configuración suele tardar unos 5 minutos.
Mientras esperamos, veamos rápidamente qué Dockerrun.aws.jsoncontiene el archivo. Este archivo es básicamente un archivo específico de AWS que le brinda a EB detalles sobre nuestra aplicación y la configuración de la ventana acoplable.
{
"AWSEBDockerrunVersion": "1",
"Image": {
"Name": "prakhar1989/catnip",
"Update": "true"
},
"Ports": [
{
"ContainerPort": 5000,
"HostPort": 8000
}
],
"Logging": "/var/log/nginx"
}
El archivo debería explicarse por sí mismo, pero siempre puedes consultar la documentación oficial para obtener más información. Proporcionamos el nombre de la imagen que EB debe usar junto con un puerto que debe abrir el contenedor.
Con suerte, a estas alturas nuestra instancia debería estar lista. Dirígete a la página EB y deberías ver una marca verde que indica que tu aplicación está viva y coleando.
Continúe y abra la URL en su navegador y debería ver la aplicación en todo su esplendor. No dudes en enviar este enlace por correo electrónico, mensajería instantánea o Snapchat a tus amigos y familiares para que ellos también puedan disfrutar de algunos gifs de gatos.
Limpiar
Una vez que haya terminado de disfrutar de la gloria de su aplicación, recuerde cerrar el entorno para que no le cobren por recursos adicionales.
¡Felicidades! ¡Ha implementado su primera aplicación Docker! Podrían parecer muchos pasos, pero con la herramienta de línea de comandos para EB casi puedes imitar la funcionalidad de Heroku con unas pocas teclas. Con suerte, estará de acuerdo en que Docker elimina muchos de los problemas de crear e implementar aplicaciones en la nube. Le recomiendo que lea la documentación de AWS sobre entornos Docker de contenedor único para tener una idea de las características que existen.
En la siguiente (y última) parte del tutorial, subiremos un poco la apuesta e implementaremos una aplicación que imita más fielmente el mundo real; una aplicación con un nivel de almacenamiento back-end persistente. ¡Vayamos directo a ello!