O su tarea es pequeña o puede dividirla en tareas más pequeñas. Y una pequeña tarea es perfecta para un microservicio.

El diseño de software es una fase esencial en el desarrollo de software. El enfoque de diseño puede afectar todo el proyecto y la forma en que maneja los diferentes requisitos.

Los desarrolladores a menudo han usado una arquitectura monolítica, agrupando todos los componentes del software en un solo módulo. Sin embargo, este enfoque puede resultar ineficiente, particularmente para aplicaciones más grandes.

Los microservicios tienen como objetivo abordar estas limitaciones. Un microservicio es una pequeña aplicación modular que realiza funciones específicas. A diferencia de las aplicaciones monolíticas, los microservicios permiten una implementación y escalado independientes. Como resultado, son más flexibles y fáciles de mantener.

La arquitectura de microservicios

La arquitectura de microservicios es un enfoque de diseño de software que divide una gran aplicación en servicios independientes, cada uno de los cuales está diseñado para abordar un requisito comercial específico.

instagram viewer

Estos servicios se ejecutan en recursos dedicados, incluidas instancias de bases de datos separadas y poder de cómputo. A diferencia de los sistemas monolíticos, las aplicaciones de microservicios se acoplan libremente, lo que permite una mayor flexibilidad.

En un sistema distribuido, los nodos del servidor implementan y ejecutan aplicaciones de microservicios por separado. Procesos: se comunican entre sí mediante protocolos de comunicación como HTTP o a través de intermediarios de mensajes. como RabbitMQ.

Esencialmente, este enfoque arquitectónico permite que los servicios mantengan su independencia entre sí mientras operan efectivamente dentro del sistema de software.

En este tutorial, lo guiaremos a través de la implementación de un microservicio de usuario simple que administra los datos del usuario mediante Flask y PostgreSQL.

Configurar una base de datos PostgreSQL

Para comenzar, instale PostgreSQL. Si no tiene PostgreSQL instalado, puede averiguarlo cómo instalar PostgreSQL en Windows o cómo instalar PostgreSQL en macOS.

Alternativamente, puede configurar un base de datos PostgreSQL remota instancia.

Esta guía utilizará el nivel gratuito de Render para configurar una base de datos PostgreSQL. Siga estos para activar una instancia de base de datos PostgreSQL en Render:

  1. Dirigirse a sitio web de renders, regístrese para obtener una cuenta e inicie sesión en su panel página.
  2. En la página de su tablero, de la lista de servicios que se muestra, seleccione el servicio PostgreSQL.
  3. En la página de configuración de la base de datos, complete los detalles requeridos y asegúrese de seleccionar el nivel libre, y finalmente haga clic en Crear base de datos.

Puedes encontrar el código de este proyecto en este repositorio GitHub.

Crear un microservicio Flask

  1. En su terminal, cree un nuevo directorio y cámbielo:
    mkdir matraz-microservicio
    cd matraz-microservicio
  2. A continuación, instale entorno virtual, para crear un entorno de desarrollo virtual aislado.
    pip instalar virtualenv
  3. Crea un entorno virtual en tu proyecto:
    entorno virtual venv
  4. Finalmente, active el entorno virtual.
    # Ventanas: 
    .\venv\Scripts\activar
    # Unix o Mac OS: 
    fuente venv/bin/activar

Instale los paquetes necesarios

  1. Crear un nuevo requisitos.txt archivo en el directorio raíz y agregue estos paquetes:
    matraz
    psycopg2-binary
    sqlalchemy
  2. A continuación, instale los paquetes.
    pip install -r requisitos.txt

Crear un servidor Flask

En el directorio raíz, cree un nuevo archivo: servicio.py, y el siguiente código:

  1. Realiza las siguientes importaciones:
    de matraz importar Frasco, solicitud, jsonify
    de sqlalchemy importar create_engine, Columna, Entero, Cadena
    de sqlalchemy.orm importar sesionista
    de sqlalchemy.ext.declarative importar base_declarativa
    importar psicopg2
  2. Cree la instancia de Flask y configure la conexión de la base de datos.
    app = Frasco (__nombre__)
    motor = crear_motor("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v")
    Copia el URL de la base de datos externa en la página de configuración de la base de datos de Render. Usaremos el SQLAlchemy create_engine método y psicopg2 para configurar la conexión a la base de datos. Asegúrese de actualizar y reemplazar la URL de la base de datos en el código anterior con la URL de su propia instancia de PostgreSQL que coincida con el formato especificado anteriormente. Si el formato de la URL es incorrecto, el código arrojará un error.
  3. Cree un modelo SQLAlchemy para la base de datos.
    Base = base_declarativa()
    claseUsuario(Base):
     __nombretabla__ = 'usuarios'
     id = Columna (Entero, clave_principal=Verdadero)
     nombre = Columna (Cadena (50))
    Base.metadata.create_all (motor)
    imprimir("La tabla 'usuarios' se creó con éxito".)
    Sesión = sesionista (motor)
    El código define un modelo de datos para la tabla de usuarios. Después de definir el modelo, crea la tabla usando el SQLAlchemy create_all método que toma la base de datos objeto de motor de conexión como parámetro. Finalmente, crea una instancia del creador de sesiones utilizando el mismo objeto de motor para permitir interacciones con la base de datos.
  4. Por último, defina las rutas API para el microservicio.
    @app.route("/api/usuario", métodos=["POST"])
    definitivamentecrear usuario():
     datos = solicitud.get_json()
     nombre = datos["nombre"]
    intentar:
     sesión = Sesión()
     nuevo_usuario = Usuario (nombre=nombre)
     session.add (nuevo_usuario)
     sesión.commit()
    devolver {"identificación": nuevo_usuario.id, "nombre": nuevo nombre de usuario, "mensaje": f"Usuario {nombre} creado."}, 201
    excepto Excepción como mi:
     imprimir(f"El error'{mi}' ocurrió.")
    devolver {"error": "Ocurrió un error al crear el usuario".}, 500
    @app.route("/api/usuario", métodos=["GET"])
    definitivamenteget_all_users():
    intentar:
     sesión = Sesión()
     usuarios = sesión.consulta (Usuario).todos()
    si usuarios:
     resultado = []
    para usuario en usuarios:
     resultado.append({"identificación": usuario.id, "nombre": nombre de usuario})
    devolver jsonify (resultado)
    demás:
    devolver jsonify({"error": f"Usuarios no encontrados".}), 404
    excepto Excepción como mi:
     imprimir(f"El error'{mi}' ocurrió.")
    devolver {"error": "Se produjo un error al obtener todos los usuarios".}, 500
    si __nombre__ == "__principal__":
     aplicación.ejecutar (depurar=Verdadero, host="0.0.0.0")

Probar el microservicio

El código anterior demuestra un microservicio de datos de usuario simple que agrega y obtiene datos de una base de datos PostgreSQL. Idealmente, los microservicios reflejan el Arquitectura API REST dado que permite un enfoque flexible para crear servicios web, esta arquitectura encaja bien con el patrón de diseño de los microservicios.

Sin embargo, es importante tener en cuenta que los microservicios también pueden usar otros tipos de enfoques de diseño y protocolos de comunicación, según las necesidades específicas del sistema.

Para probar el servicio, active el servidor de desarrollo y diríjase a Postman para realizar solicitudes HTTP a los puntos finales definidos.

matraz --ejecución del servicio de la aplicación

En Postman, realice una solicitud POST para agregar datos de usuario.

Microservicios en contenedores con Docker

Docker empaqueta aplicaciones y sus dependencias en contenedores. Este enfoque agiliza el desarrollo, la implementación y la gestión de microservicios en un entorno de producción. ya que cada servicio puede operar de forma independiente y comunicarse con otros servicios utilizando la comunicación configurada protocolo.

Antes de comenzar, primero debe instalar Docker siguiendo los pasos en el sitio web acoplable. Luego, cree una imagen de Docker a partir de un Dockerfile que contenga las instrucciones necesarias para configurar las dependencias requeridas para ejecutar la aplicación en un contenedor.

  1. Cree un Dockerfile en el directorio raíz de la carpeta de su proyecto y agregue estas instrucciones:
    DE pitón:3.9-alpino
    DIR.TRABAJO /app
    COPIAR requisitos.txt ./
    CORRER pip install -r requisitos.txt
    COPIAR. .
    EXPONER5000
    CMD ["pitón", "./servicio.py"]
  2. Ejecute el siguiente comando para crear la imagen de Docker.
     docker build -t matraz-microservicio.
  3. Finalmente, ejecute el contenedor Docker.
    docker run -p 5000:5000 matraz-microservicio

Esto iniciará un contenedor Docker que ejecuta el microservicio Flask y expondrá el puerto 5000 en el contenedor para puerto 8000 en la máquina host, lo que le permite realizar solicitudes HTTP desde su navegador web o Postman usando el URL http://localhost: 5000.

Adopción de la arquitectura de microservicios

La arquitectura de microservicios se ha convertido en un enfoque popular para desarrollar aplicaciones de software robustas y escalables. Al dividir la aplicación en pequeños servicios que se implementan de forma independiente, la arquitectura de microservicios facilita el mantenimiento y la escala del sistema.

Si bien esta arquitectura tiene beneficios potenciales, no es adecuada para todos los casos de uso. En cualquier caso, los requisitos comerciales específicos del proyecto deben influir principalmente en el enfoque de diseño adoptado.