Docker Compose: NGINX PROXY MANAGER + PHPMYADMIN + MYSQL + FASTAPI (con Python) Servicio REST

por
Tiempo de lectura: 3 minutos

En este tutorial, te enseñaremos cómo crear un contenedor Docker con NGINX Proxy Manager, phpMyAdmin, MySQL y FastAPI (con Python) utilizando Docker Compose. Esto te permitirá tener una pila completa para el desarrollo web y API en un solo contenedor.

Requisitos previos

Antes de comenzar, necesitarás tener Docker y Docker Compose instalados en tu máquina. Si aún no lo has hecho, sigue los siguientes pasos:

  1. Descarga e instala Docker Desktop desde el sitio web oficial: https://www.docker.com/products/docker-desktop
  2. Verifica que Docker se haya instalado correctamente ejecutando el siguiente comando en la terminal:css
docker --version

Deberías ver la versión de Docker que has instalado.

Instala Docker Compose siguiendo las instrucciones en la documentación oficial: https://docs.docker.com/compose/install/

Verifica que Docker Compose se haya instalado correctamente ejecutando el siguiente comando en la terminal:

  1. docker-compose --version Deberías ver la versión de Docker Compose que has instalado.

Paso 1: Crear el archivo docker-compose.yml

Lo primero que necesitamos hacer es crear un archivo docker-compose.yml en un nuevo directorio. Puedes hacerlo ejecutando el siguiente comando en la terminal:

mkdir myapp && cd myapp
touch docker-compose.yml

Luego, abre el archivo docker-compose.yml en tu editor de texto favorito y agrega el siguiente contenido:

version: "3.8"
services:
  proxy:
    image: jlesage/nginx-proxy-manager:latest
    container_name: proxy
    restart: always
    ports:
      - "80:80"
      - "443:443"
      - "81:81"
    environment:
      - TZ=America/New_York
      - PUID=1000
      - PGID=1000
    volumes:
      - ./data:/config
      - ./letsencrypt:/etc/letsencrypt
      - ./nginx.tmpl:/app/nginx.tmpl:ro
  phpmyadmin:
    image: phpmyadmin/phpmyadmin:latest
    container_name: phpmyadmin
    restart: always
    ports:
      - "8080:80"
    environment:
      - PMA_HOST=mysql
      - PMA_USER=root
      - PMA_PASSWORD=my-secret-pw
  mysql:
    image: mysql:8
    container_name: mysql
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=my-secret-pw
    volumes:
      - mysql-data:/var/lib/mysql
  app:
    build: ./app
    container_name: app
    restart: always
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=mysql+pymysql://root:my-secret-pw@mysql:3306/mydatabase
    depends_on:
      - mysql
volumes:
  mysql-data:

Este archivo define cuatro servicios:

  1. proxy: utiliza la imagen de NGINX Proxy Manager para manejar la gestión de proxy inverso y la gestión de certificados SSL.
  2. phpmyadmin: utiliza la imagen de phpMyAdmin para proporcionar una interfaz gráfica de usuario para MySQL.
  3. mysql: utiliza la imagen oficial de MySQL para el servidor de base de datos.
  4. app: construye la imagen de la aplicación FastAPI utilizando el archivo Dockerfile ubicado en el directorio ./app.

Paso 2: Crear la aplicación FastAPI

Ahora necesitamos crear la aplicación FastAPI. En este tutorial, utilizaremos un ejemplo simple que muestra cómo conectarse a la base de datos MySQL.

Primero, crea un nuevo directorio app dentro del directorio myapp. Luego, crea un archivo app/main.py con el siguiente contenido:

from fastapi import FastAPI
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

app = FastAPI()

DATABASE_URL = "mysql+pymysql://root:my-secret-pw@mysql:3306/mydatabase"

engine = create_engine(DATABASE_URL)

SessionLocal = sessionmaker(bind=engine)

@app.get("/")
async def root():
    return {"message": "Hello World"}

Este archivo define una aplicación FastAPI básica con una ruta raíz que devuelve un mensaje de saludo.

Luego, crea un archivo app/Dockerfile con el siguiente contenido:

FROM python:3.9

WORKDIR /app

COPY requirements.txt ./
RUN pip install -r requirements.txt

COPY ./app .

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Este archivo define la imagen Docker para nuestra aplicación FastAPI, que utiliza Python 3.9 y se ejecuta en el puerto 8000.

Finalmente, crea un archivo app/requirements.txt con el siguiente contenido:

fastapi
uvicorn
SQLAlchemy
pymysql

Este archivo define las dependencias de nuestra aplicación, que incluyen FastAPI, Uvicorn, SQLAlchemy y PyMySQL.

Paso 3: Ejecutar el contenedor Docker

Ahora estamos listos para ejecutar el contenedor Docker utilizando Docker Compose.

Para hacerlo, asegúrate de que te encuentras en el directorio myapp y ejecuta el siguiente comando en la terminal:

docker-compose up -d

Este comando iniciará los cuatro servicios definidos en el archivo docker-compose.yml en modo detached, lo que significa que se ejecutarán en segundo plano.

Una vez que los contenedores estén en ejecución, puedes acceder a las siguientes URL desde tu navegador web:

Conclusión

En este tutorial, aprendiste cómo crear un contenedor Docker que incluye NGINX Proxy Manager, phpMyAdmin, MySQL y FastAPI. Utilizando Docker Compose, pudiste definir y ejecutar todos estos servicios en un solo comando. Este enfoque te permite crear aplicaciones web y API más complejas en un entorno controlado y escalable.

Post Views: 5

Deja un comentario