Este tutorial le guiará a través del proceso de acceso a una aplicación web que se ejecuta en un contenedor Docker. Aprenderá los fundamentos de los contenedores Docker, desplegará una aplicación web simple y descubrirá cómo acceder a ella desde su máquina host. Este conocimiento es esencial para desarrollar y probar aplicaciones web utilizando Docker.
Docker es una plataforma que utiliza la containerización para empaquetar aplicaciones y sus dependencias juntas. Esto permite que las aplicaciones se ejecuten de manera consistente en diferentes entornos.
Primero, verifiquemos si Docker está correctamente instalado en su sistema:
docker --versionDebería ver una salida similar a esta, mostrando la versión de Docker:
Docker version 20.10.21, build baeda1fEn la terminología de Docker:
Piense en una imagen Docker como un plano y en un contenedor Docker como un edificio creado a partir de ese plano.
Ejecutemos un contenedor simple para verificar que Docker funciona correctamente:
docker run hello-worldDebería ver una salida como esta:
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
...Esto confirma que Docker funciona correctamente en su sistema.
Aquí hay algunos comandos esenciales de Docker que debe conocer:
docker psdocker ps -adocker imagesPruebe estos comandos y observe las salidas. Después de ejecutar el contenedor hello-world, debería verlo listado cuando ejecute docker ps -a (pero no en docker ps ya que sale inmediatamente después de mostrar el mensaje).
En este paso, crearemos una aplicación web simple utilizando Python y Flask que podemos desplegar en un contenedor Docker.
Primero, creemos un nuevo directorio para nuestra aplicación web:
mkdir -p ~/project/my-web-app
cd ~/project/my-web-appAhora, creemos una aplicación Flask simple. Cree un archivo llamado app.py usando el editor nano:
nano app.pyAgregue el siguiente código Python al archivo:
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
return "<h1>Hello from Docker!</h1><p>This is a simple web application running in a Docker container.</p>"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)Presione Ctrl+O seguido de Enter para guardar el archivo, luego Ctrl+X para salir de nano.
A continuación, cree un archivo requirements.txt para especificar las dependencias de nuestra aplicación:
nano requirements.txtAgregue la siguiente línea al archivo:
flask==2.0.1Presione Ctrl+O seguido de Enter para guardar el archivo, luego Ctrl+X para salir de nano.
Ahora, creemos un Dockerfile para definir cómo debe ser containerizada nuestra aplicación:
nano DockerfileAgregue el siguiente contenido al archivo:
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
EXPOSE 5000
CMD ["python", "app.py"]Este Dockerfile hace lo siguiente:
/app.Presione Ctrl+O seguido de Enter para guardar el archivo, luego Ctrl+X para salir de nano.
Ahora, construyamos una imagen Docker desde nuestro Dockerfile:
docker build -t my-flask-app .La bandera -t etiqueta nuestra imagen con el nombre my-flask-app. El . al final especifica que el Dockerfile está en el directorio actual.
Debería ver una salida similar a esta:
Sending build context to Docker daemon x.xxxkB
Step 1/6 : FROM python:3.9-slim
---> xxxxxxxxxx
Step 2/6 : WORKDIR /app
---> Using cache
---> xxxxxxxxxx
...
Successfully built xxxxxxxxxx
Successfully tagged my-flask-app:latestAhora, verifique que su imagen fue creada:
docker images | grep my-flask-appDebería ver su imagen recién creada en la lista.
Ahora que hemos construido nuestra imagen Docker, ejecutémosla como un contenedor y accedamos a la aplicación web.
Para ejecutar el contenedor y mapear el puerto para que podamos acceder a la aplicación web, use el siguiente comando:
docker run -d -p 5000:5000 --name my-web-container my-flask-appEste comando hace lo siguiente:
-d: Ejecuta el contenedor en modo desasociado (en segundo plano)-p 5000:5000: Mapea el puerto 5000 del contenedor al puerto 5000 en el host--name my-web-container: Asigna un nombre al contenedormy-flask-app: Especifica la imagen a utilizarVerifiquemos que nuestro contenedor se está ejecutando:
docker psDebería ver una salida similar a esta:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
xxxxxxxxxxxx my-flask-app "python app.py" xx seconds ago Up xx seconds 0.0.0.0:5000->5000/tcp my-web-containerAhora, puede acceder a la aplicación web de dos maneras:
curl http://localhost:5000Debería ver la respuesta HTML:
<h1>Hello from Docker!</h1><p>This is a simple web application running in a Docker container.</p>http://localhost:5000 en la barra de direccionesCuando ejecutamos un contenedor con -p 5000:5000, estamos creando un mapeo entre:
Esto significa que cualquier tráfico enviado al puerto 5000 en la máquina host se reenviará al puerto 5000 dentro del contenedor.
También podríamos usar diferentes números de puerto. Por ejemplo, -p 8080:5000 mapearía el puerto del host 8080 al puerto del contenedor 5000, lo que le permitiría acceder a la aplicación en http://localhost:8080.
Si necesita ver los registros del contenedor (lo cual puede ser útil para la depuración), use:
docker logs my-web-containerDebería ver los mensajes de inicio de la aplicación Flask.
Para detener el contenedor, use:
docker stop my-web-containerPara eliminar el contenedor detenido, use:
docker rm my-web-containerTambién puede detener y eliminar un contenedor en un solo comando:
docker rm -f my-web-containerEsto es útil durante el desarrollo cuando desea reconstruir y volver a ejecutar su contenedor rápidamente.
Ahora que ha ejecutado con éxito su aplicación web en un contenedor Docker, exploremos algunas características y técnicas adicionales para administrar contenedores Docker.
Puede ejecutar múltiples instancias de su aplicación web en diferentes puertos. Esto es útil para realizar pruebas o ejecutar diferentes versiones de su aplicación simultáneamente.
Primero, detengamos y eliminemos nuestro contenedor anterior:
docker rm -f my-web-containerAhora, ejecutemos dos instancias de nuestra aplicación web en diferentes puertos:
docker run -d -p 5000:5000 --name web-app-1 my-flask-app
docker run -d -p 5001:5000 --name web-app-2 my-flask-appVerifique que ambos contenedores se estén ejecutando:
docker psDebería ver dos contenedores en ejecución:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
xxxxxxxxxxxx my-flask-app "python app.py" xx seconds ago Up xx seconds 0.0.0.0:5001->5000/tcp web-app-2
xxxxxxxxxxxx my-flask-app "python app.py" xx seconds ago Up xx seconds 0.0.0.0:5000->5000/tcp web-app-1Ahora puede acceder a la misma aplicación en dos puertos diferentes:
Docker le permite establecer límites de recursos para sus contenedores. Esto es útil para evitar que un contenedor consuma demasiados recursos del sistema.
Detengamos y eliminemos nuestros contenedores anteriores:
docker rm -f web-app-1 web-app-2Ahora, ejecutemos un contenedor con límites de memoria y CPU:
docker run -d -p 5000:5000 --name limited-container --memory=512m --cpus=0.5 my-flask-appEste comando crea un contenedor con:
Verifique que el contenedor se esté ejecutando:
docker psLas variables de entorno son una forma común de configurar aplicaciones en contenedores Docker. Modifiquemos nuestra aplicación Flask para usar una variable de entorno:
docker rm -f limited-containerCree una nueva versión del archivo app.py:
cd ~/project/my-web-app
nano app_env.pyAgregue el siguiente código:
import os
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
app_name = os.environ.get('APP_NAME', 'Default App')
return f"<h1>Hello from {app_name}!</h1><p>This is a simple web application running in a Docker container.</p>"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)Presione Ctrl+O seguido de Enter para guardar el archivo, luego Ctrl+X para salir de nano.
Cree un nuevo Dockerfile:
nano Dockerfile-envAgregue el siguiente contenido:
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app_env.py ./app.py
EXPOSE 5000
CMD ["python", "app.py"]Presione Ctrl+O seguido de Enter para guardar el archivo, luego Ctrl+X para salir de nano.
Construya una nueva imagen:
docker build -t my-flask-app-env -f Dockerfile-env .Ahora, ejecute el contenedor con una variable de entorno:
docker run -d -p 5000:5000 --name env-container -e APP_NAME="Customized App" my-flask-app-envAcceda a la aplicación web:
curl http://localhost:5000Debería ver:
<h1>Hello from Customized App!</h1><p>This is a simple web application running in a Docker container.</p>Esto demuestra cómo pasar la configuración a sus aplicaciones en contenedores utilizando variables de entorno.
En este laboratorio, aprendió a acceder a una aplicación web que se ejecuta en un contenedor Docker. Creó una sencilla aplicación web Flask, la contenedorizó usando Docker y accedió a ella desde su máquina host usando el mapeo de puertos.
Conceptos clave cubiertos:
Estas habilidades proporcionan una base sólida para trabajar con aplicaciones en contenedores y le ayudarán a implementar y probar aplicaciones web de manera eficiente utilizando Docker.
