Crear e importar los Microservicios - Tutoriales Spring Boot y Angular

🎯 Objetivos

Al terminar esta guía, podrás:

Generar microservicios básicos usando Spring Boot.
Importar esos microservicios en tu proyecto global.
Tener una estructura por capas de cada microservicio que sea escalable y mantenible a futuro (la base para el e-commerce).
Conectar cada microservicio a una base de datos PostgreSQL usando Docker
Validar que los microservicios estén funcionales y pueda iniciarse si problema

1. Crear los microservicios usando Spring Initializr

En este apartado del curso creamos los microservicios del proyecto, inicialmente vamos a crear el microservicio para gestionar un producto:

product-service

Para esto vamos a usar Spring Initializr que es una herramienta web que simplifica la creación de proyectos Spring Boot al generar automáticamente la estructura inicial del proyecto con las dependencias y configuraciones deseadas.

Vamos a un navegador y copiamos la siguiente url: https://start.spring.io/

Ya en la web oficial vamos a rellenar cada uno de los campos indicados como se muestra en la siguiente imagen:

Nota: En el caso de la versión de Spring Boot por defecto a la fecha de la creación del curso es la 3.5.6 pero esto puede variar, lo recomendado es elegir siempre la que se muestra por defecto.

Una vez que hemos indicado tanto las herramientas, el Project Metadata y las dependencias vamos a darle click en la opción GENERATE CTRL, esto va descargar un archivo con el nombre que se muestra en la siguiente imagen:

En este caso hemos creado el arquetipo de proyecto para el microservicio product-service, lo siguiente que vas a realizar es el mismo ejercicio para crear el resto de microservicios del proyecto.

Tarea:

Crear los siguientes microservicios:

order-service
inventory-service
client-service
payment-service

2. Importar los microservicios como módulos en Intellij IDEA

Una vez creados los microservicios vamos a importarlos en Intellij IDEA para esto vas a realizar lo siguiente:

En tu computador en una ruta accesible tanto para lectura y escritura vas a crear un directorio llamado microservices, dentro de este directorio vas a descomprimir cada microservicio que finalmente va quedar como se muestra a continuación (se debe eliminar los archivos .zip):

Nota: Cada microservicio debe quedar con la siguiente estructura, por ejemplo el microservicio producto-service debe quedar de la siguiente manera:

Lo siguiente que vas a hacer es abrir Intellij IDEA y abrir el directorio microservices e importar como módulos los microservicios creados anteriormente**:**

Hay algunas formas de importar o abrir un proyecto en Intellij IDEA, en las siguientes imágenes se muestras las 2 opciones que se indican en este curso de como hacerlo.

Para esto realizas los pasos que se describen a continuación:

Esta es otra opción con la que puedes abrir un proyecto, elije la que se adapte a tu context:

Buscas la ubicación donde se encuentra el directorio microservices y le das OK:

Te va pedir que confirmes si es un directorio de confianza:

Importante: En la parte inferior derecha le vas a dar en el cuadro de diálogo en el botón Load, esto permite configurar los proyectos como módulos en Intellij IDEA

Finalmente la estructura del proyecto debe quedar de la siguiente manera:

3. Crear la estructura de paquetes, conexión a BDD y arrancar el microservicio product-service

Vamos a empezar creando la estructura de paquetes del microservicio product-service, la idea es dividir el microservicio en capas en las que cada capa tenga una única responsabilidad, con esto vamos a tener un proyecto mantenible, escalable y que sigue buenas practicas de desarrollo.

Si expandimos el microservicio product-service, seguidamente dentro del directorio src, main y finalmente java, vamos a tener una estructura como se muestra en la imagen a continuación: un paquete principal y la clase de arranque de nuestro proyecto.

Inicialmente vamos a crear los siguientes paquetes: entity, repository, service, controller, para esto te sitúas en el paquete principal le das click derecho elijes New y luego la opción Package y luego el nombre respectivo de cada paquete indicado anteriormente:

Al final tendrás una estructura como la que se muestra a continuación:

4. Configuración para trabajar con una BDD PostgreSQL

En el mismo microservicio product-service, expandimos el directorio resources y abrimos el archivo application.properties para crear la conexión a BDD. La conexión a base de datos queda de la siguiente manera:

# ===============================
# = DataSource
# ===============================
spring.datasource.url=jdbc:postgresql://localhost:5435/productdb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=org.postgresql.Driver

# ===============================
# = JPA / Hibernate
# ===============================
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

Desde la línea 6 hasta la 9 definimos la conexión a BDD: vamos a usar una base de datos llamada productdb (la crearemos posteriormente) y los accesos (nombre de usuario y contraseña).

Desde la línea 14 hasta la 16 son netamente temas de JPA/Hibernate, por ejemplo en la línea 14 indicamos que nos permita ver mediante consola tipo logs las sentencias SQL que ejecuta JPA, en la línea 15 definimos la forma que se van a crear las tablas en la BDD, en este caso la primera vez que arranque la aplicación va crear todas las tablas que estén mapeadas con JPA, posteriormente sólo actualizará campos o tablas nuevas que no estén en el esquema manteniendo la información guardada anteriormente.

5. Uso de Docker para trabajar con PostgreSQL

Actualmente ya podríamos arrancar nuestro microservicio product-service sin embargo vamos a tener un error porque no puede acceder a la BDD productdb definida en el archivo application.properties, en este caso podríamos instalar el motor de BDD PostgreSQL en nuestro equipo y crear cada bdd de cada microservicio, sin embargo vamos a usar una imagen de Docker con las instalación de PostgreSQL y de esta manera evitamos hacer la instalación en local.

Descargar una imagen y levantar un contenedor con la instalación de PostgreSQL

Lo primero que vas hacer es copiar y pegar el comando descrito a continuación en un consola CMD o PowerShell y ejecutarlo, esto arrancará una contenedor con la instalación de PostgreSQL (si no encuentra la imagen en local la va descargar y luego va arrancar el contenedor, esto se lo hace una sola vez luego ya gestionas usando Docker Desktop).

Importante: Antes de ejecutar el comando de docker asegúrate de tener levantado Docker Desktop

docker run --name product-container-postgres -e POSTGRES_USER=root  -e POSTGRES_PASSWORD=root  -e POSTGRES_DB=productdb  -p 5435:5432  -v product_data:/var/lib/postgresql/data  -d postgres

Explicación del comando anterior:

docker run→ Crea y ejecuta un contenedor nuevo.
-name product-container-postgres→ Le da un nombre al contenedor (product-container-postgres) para no tener que usar el ID largo.
e POSTGRES_USER=root→ Crea el usuario principal de la base de datos llamado root.
e POSTGRES_PASSWORD=root→ Asigna la contraseña para ese usuario (root).
e POSTGRES_DB=productdb→ Crea automáticamente una base de datos inicial llamada productdb.
p 5435:5432→ Expone el puerto 5432 del contenedor en el puerto 5435 de tu máquina host. Así puedes conectarte desde aplicaciones externas (ejemplo: DBeaver, IntelliJ, pgAdmin, Spring Boot, etc.).
v product_data:/var/lib/postgresql/data→ Crea un volumen llamado postgres_data que guarda los datos de PostgreSQL en tu máquina. Esto hace que los datos no se pierdan aunque detengas o elimines el contenedor.
d→ Corre el contenedor en modo detached (en segundo plano). Si no lo usas, verías los logs en la terminal.
postgres→ Es la imagen oficial de PostgreSQL (última versión por defecto si no indicas un tag como :13 o :16).

Posterior a la ejecución del comando vas a visualizar la siguiente salida por consola:

En Docker Desktop veras lo siguiente:

Nota: Si quieres tener mas referencia o información sobre la imagen oficial de docker puedes visitar la web oficial de dockerhub: https://hub.docker.com/_/postgres

Detener un contenedor

Para detener un contenedor lo puedes hacer mediante Power Shell, CMC o usar la interfaz Docker Desktop como se muestra a continuación:

Iniciar un contenedor

Para iniciar un contenedor lo puedes hacer mediante Power Shell, CMC o usar la interfaz Docker Desktop como se muestra a continuación:

Ingresar por la consola a PostgreSQL

Puedes también ingresar por consola al contenedor y a gestionar la BDD productdb, para esto debes ejecutar el siguiente comando:

docker exec -it product-container-postgres  psql -U root -d productdb

Ya dentro del motor de PostgreSQL puedes ejecutar comandos SQL u otras sentencias propias del motor de base datos:

\dt     -- ver tablas
\q      -- salir

Arrancar el microservicio product-service

Una vez creada la base de datos ya puedes iniciar el microservicio para esto debes abrir la clase de arranque:

Y darle click a cualquier de los iconos de color verde:

Como se puede observar en la imagen finalmente tendremos levantado el microservicio product-service

Tarea:

Realizar el mismo ejercicio para el resto de microservicios, desde el paso 3 debes realizar los mismos pasos hasta levantar cada uno de los microservicios, el nombre de las bases de datos para cada microservicio serán las siguientes:

order-service (orderdb y puerto 5436)
inventory-service (inventorydb y puerto 5437)
client-service (clientdb y puerto 5438)
payment-service (paymentdb y puerto 5439)

Importante Docker: Para levantar otro contenedor debes cambiar el nombre, número del puerto de tu host por ejemplo 5436:5432 y el volumen caso contrario vas a tener un error debido a que ya existe un contenedor escuchando por ese puerto y con ese nombre.

Ejemplo para levantar el contenedor para la BDD del microservicio order-service (orderdb)

docker run --name order-container-postgres -e POSTGRES_USER=root  -e POSTGRES_PASSWORD=root  -e POSTGRES_DB=orderdb  -p 5436:5432  -v order_data:/var/lib/postgresql/data  -d postgres

Importante: En el archivo application.properties de cada microservicio debes cambiar el puerto por defecto (que es el 8080) que se levanta el microservicio y la cadena de conexión a BDD.

En el caso del microservicio product-service se levanta por defecto en el puerto 8080 aunque no esté explícitamente descrito, por ejemplo para la configuración del microservicio order-service su puerto y su cadena de conexión queda de la siguiente manera:

server.port=8081

spring.datasource.url=jdbc:postgresql://localhost:5436/orderdb

A continuación te dejo los puertos que vamos a usar para este curso:

order-service (8081)
inventory-service (8082)
client-service (8083)
payment-service (8084)

Proyecto al finalizar esta guía:

Accede a GitHub para revisar la solución y como debería quedar el proyecto al finalizar esta guía

Proyecto github