Spring Cloud grupo 1 | Videos

language: ES

                  WEBVTT
y
Armando, a César, Ángel ya está,
sí. Buenos días. Perfecto.                

on 2023-08-31

language: ES

                  WEBVTT
va. Igual pueden aplicar este comando, por favor, para ver que sea la versión de 17,
ya va 17, que es con la que vamos a estar este trabajando.
No, es en la virtual, todo esto es en la virtual.
Por favor.
Este, sí, sí, sí, lo ocupo.
Ah, sí, sí, no, es este, utilizando la versión Nepal.
Sí, eh, probablemente lo que tengas que hacer es aquí, mira, aquí se ve una.
Pero se ve como un.
Un cuadrito, una tangulito para colapsar.
Si tú lo presionas, ya te va a parecer esa lista.
Ajá.
Acá en el cuadro de búsqueda.
En el cuadro de búsqueda presionas o escribes más bien Intel y Intel.
Y te tiene que aparecer el ID de Intel y perfecto.
Ale.
No, ahí, ahí nada más es abrir que ver que tenemos Intel y sale este más.
Entonces lo siguiente, ya que tenemos esos tres checados, vamos a bueno,
Spring Boot lo tenemos por las librerías que vamos a ir agregando en los proyectos.
En este caso también más le recordar o mencionar más bien que la versión que
vamos a estar ocupando de Spring Boot es la 2.6.3.
Si bien no es una versión la más actual, no la más moderna,
es una que es muy compatible con todo el ecosistema de Spring Cloud,
que es que es muy compatible con la versión de Java 17.
Y bueno, también este sirve porque bueno, es una de las versiones más comerciales.
Este que puedes estar encontrándote trabajando.
Entonces nada más me gusta hacer como esta aclaración de que sí, en efecto,
no es la versión tres y pedazo que va, creo que de Spring Boot,
pero bueno, es la que mejor se complementaba.
Entonces esto lo vamos a utilizar ahorita en los POM.
Vamos a ver la librería.
Luego viene la versión de Spring Cloud que igual está.
Estas tres básicamente son librerías que vamos a estar añadiendo en los archivos POM.
Va la versión de Spring Cloud es la 2021.00.
Igual es, solamente porque es muy, muy compatible con estas.
Quienes nos dedicamos al desarrollo de aplicaciones con Spring,
Spring Boot, Java, todo esto, Maven, Gradle, todo eso.
Pues sabemos que a veces entre bueno,
se batalla un poquito en conjugar o encontrar las versiones que hacen Max.
No, pero bueno, ahorita ya todo esto está probado como para que nosotros ya nada más
desarrollemos.
Luego, pues también obviamente se ocupa Maven.
Este es el sistema para gestión, el gestor de paquetes.
Entonces, este es lo que también vamos a ver ahorita en el POM.
Están todos estos incluidos.
Entonces esto lo podemos obviar ahorita.
Vamos a estar ocupando de base de datos, lo que es Postgres.
Ajá.
Y un cliente.
En este caso, nuestro cliente va a ser Dbware.
Pero bueno, tú también, si quieres, puedes instalarte el PG admin en un rato que tengas ahí de tiempo.
Puedes ocupar el cliente que a ti te, te, más te, te acomode, no?
En mi caso, pues instale este como para variar el stack.
Entonces, este, para checar que tenemos Postgres.
El cliente ahorita igual en el cuadro de búsqueda, escriben D.
Diver y debe de aparecer este castorcito.
Igual lo ejecutan como administrador.
Y con eso también le damos cheque al siguiente.
No voy a ir monitoreando aquí en sus máquinas.
Veo que ya varios ya lo abrieron.
Perfecto.
Bien.
Y va abriendo, va abriendo.
Dale.
Ya varios tenemos ahí.
Al castorcito.
Sale.
Ah, perdón.
Ah, el último es este Dbware.
Entonces, no es más que aquí en el cuadro de diálogo.
Presionas Dbware.
Escribes debe y te va a aparecer ahí un castor.
Y ya lo abres como administrador y ya se abre esta.
Esta consola.
Entonces, ya que tenemos también Dbware, este.
La parte de Kafka.
Yo creo que aquí ya hacemos la la pauta para mostrar.
Lo que es cómo se conecta, cómo está funcionando todo esto del Docker.
Docker de esto.
Dale.
Entonces miren.
Ok.
A ver, déjenme minimizar todas estas ventanas.
Bueno, a ver, entonces esta esta interfaz se llama Docker de esto.
No sé si ya han utilizado lo que es este Docker.
Pero bueno, de todos modos.
Ah, perfecto.
Bien.
Entonces, entonces esta parte.
Este.
De Docker.
La la la vamos a ocupar así.
Nosotros tenemos un archivo de configuración que ahorita se los voy a mostrar.
Este.
Y básicamente, este este.
Este aplicativo lo que nos permite es crear o empaquetar.
Bueno, crear contenedores.
El concepto es empaquetar varios.
Como decirlo, productos o software en un mismo.
Y contenedor.
Ese es el.
Esa es la definición.
El contenedor sale.
Entonces yo en este caso hice un un contenedor que se llama PostgreSQL y Kafka.
Y lo que tiene contenido dentro es una instancia de Kafka contiene las bases de datos de tres.
Bueno, ya es el pomodoro, pero vamos a terminar de explicar esto y tomamos el pomodoro.
Va a los cinco minutos.
Entonces es este.
Básicamente se contiene los empaquetar en este contenedor.
Lo que es este Kafka.
Lo que son las tres conexiones a bases de datos que son las de producto, usuario, órdenes.
Y bueno, en relación a lo de Kafka también tenemos un otro.
Este.
También tenemos un otro.
Este.
Y producto que se llama su Kipper, otro software que se ocupa con Kafka.
Sale entonces.
Bueno, esto todo esto se empaquetan este se le llama contenedor.
Va, vamos a ver ese archivo de forma.
Un poquito más a detalle.
Que es su blime text.
Voy a abrir aquí su blime text.
Y vamos a ver que es este.
Este también lo pueden tener ustedes.
Y.
Si quieren, vamos a tomar el descanso porque si es grande la explicación que vamos a dar.
Vamos a nada más.
Hablan su blime text para eso en el cuadro de búsqueda escriban la palabra sublime.
Y este debe aparecer este igual lo ejecutan como administrador.
Y ahorita que regresemos de los cinco minutos.
Bueno, ahí está.
Bueno, ahí está.
Vale.
Bien, entonces.
Va.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Y ahora vamos a ver.
Va.
Entonces nada más déjame que se quite esa cosa negra.
Ya.
Listo.
Entonces.
Les decía que aquí en la máquina.
Eh.
¿Pueden cerrar su micrófono por favor?
Para que no se oiga tanto el ruido.
Bien.
Salen.
Muchas gracias.
Entonces, este.
Ya.
Una vez que abrimos en el Sublime Text.
Les decía que voy a explicarles la forma en la que se creó este contenedor.
Este contenedor básicamente.
Lo que nos ayuda es a tener Kafka.
Lo que nos ayuda es a tener.
Además.
Tres bases de datos.
Que son las bases de datos de los tres microservicios que vamos a ocupar.
El de producto, el de usuario y el de órdenes.
Y.
Bueno se instala también.
Software adicional que es SoKeyper.
Que lo ocupa Kafka.
Va.
Entonces.
Básicamente la idea es que cuando nosotros tengamos ese.
Empaquetado.
Ese contenedor.
Nosotros lo podremos ejecutar.
Y.
Con solo ejecutar este contenedor.
Que se ve aquí.
Contiene.
Vaga la redundancia de la palabra.
Todos estos software.
Y se van a ejecutar estos software.
Gracias a la ejecución de este.
Va.
Entonces es como que si te fijas.
Estoy guardando.
Estoy guardando todos estos software.
O estos paquetes dentro de este contenedor.
Que se llama PostgreSQL Kafka.
Va.
Ese es como.
El concepto de Docker.
Entonces para hacer eso.
Yo.
Aquí en el Sublime Text.
Voy a abrir un archivo.
Que.
Que es un archivo.
Yamel.
Que básicamente esos archivos se ocupan.
Para dictarle a Docker.
Como se deben de.
De crear los contenedores.
Ustedes lo tienen que tener también.
Ahí en su.
En su carpeta de descargas.
Van a ver.
Una carpeta que se llama Spring Cloud.
Si.
Y dentro de esta.
Una carpeta que se llama PostgreSQL Kafka.
Cuando ustedes se meten.
Adentro de esa carpeta.
Van a encontrar un archivo que se llama.
Docker.
Compose.
Yamel.
Va.
Ese archivo es el que hay que abrir.
Con este.
Eh.
Con Sublime Text.
Va.
Y bueno.
Teniendo ya este archivo.
Abierto.
Ahora si podemos ver.
Eh.
Como se va.
Eh.
Como se va armando.
Este archivo.
Yamel.
Este.
Y la base de datos es esta.
Va.
Estoy diciendo que se conecta al puerto 5432.
Muy importante tener ahorita.
Noción del puerto.
Porque como estamos ocupando muchos microservicios.
Hay que estar asignando diferentes puertos.
Entonces es muy importante tener en cuenta.
El tema.
Del puerto va.
Este se va al 5432.
Si.
Y los volúmenes que está ocupando.
Son estos de acá.
Voy a explicar este en detalle.
El de usuarios.
Este de usuarios.
Al decirle a nosotros que ocupe estos volúmenes.
Es como decirle que cree.
Que además de que me cree una base de datos.
De.
Postgres.
Además la ocupe.
Y me cree.
Ciertas tablas.
Eh.
Por default.
Y además le meta cierta información por default.
El DDL.
Es el data definition language.
Nos va a permitir crear las tablas.
Si que se ocupen.
Y el DML.
Data manipulation language.
Nos va a permitir hacer insert.
Seleccion.
En este caso lo voy a usar yo para hacer los create tables.
Y los inserts.
Sobre esas tablas creadas.
Entonces para hacer eso.
Si te fijas aquí me dice que se tiene que ir a una.
A una con una carpeta que se llama.
SQL y ahí voy a encontrar los archivos.
DDL y DML para user.
Entonces yo igual le doy aquí en open file.
Sale este.
Y aquí adentro está esta carpeta SQL.
Estas de acá estas tres estas otras tres carpetas.
De hecho se crean cuando yo levanto la instancia del contenedor.
Estas tres no les hagas caso la de order data product data user data.
No no no les hagas caso las que ocupamos son la de Docker Compose.
El archivo y lo que está dentro de esta carpeta SQL.
Y si te fijas esta carpeta vamos a ver los de usuario aquí vas a encontrar.
El DDL y el DML de usuarios.
Vas a encontrar el DDL y el DML de productos.
El DDL y el DML de órdenes.
Va entonces ahorita nos vamos a centrar en los dos de usuarios.
Tanto el DDL como el DML.
Entonces yo abro el.
Adelante.
Más bien de donde los va a obtener.
Si esto esto que dice volúmenes le está diciendo que.
De esta de estas carpetas que ves aquí que son SQL de estos dos archivos.
SQL los ocupe para generar los volúmenes de base de datos.
En este caso yo le estoy diciendo que ocupe estos archivos.
Y estos archivos son el DDL y el DML.
El DDL.
Ajá el DDL para el servicio de usuarios nos va a permitir crear una tabla.
Esa tabla es esta hace un create table.
Se llama user y tiene estos tres campos.
Va una ID un username y un email y son de estos tipos.
Son un serial para el ID es un auto incremental.
Es un username con un bar chart de 255 y un email con un bar chart de 255.
Y.
Adelante.
Sí, entonces este docker compose para esta instancia de postgres SQL para el micro
servicio de usuarios nos estaría creando esta tabla y.
Además estaría usando este archivo DML para insertar la información a esa tabla.
Si te fijas yo tengo el insert hacia que corresponde a esta estructura de esta tabla.
Si te fijas yo aquí no paso el ID porque el ID yo lo declaré en la tabla como serial.
Es decir, como auto incremental.
Entonces es necesario que yo se lo mande.
Se va a estar creando en automático.
Yo nada más le voy a pasar el username y el email.
Vale.
Y con eso yo ya estaría haciendo que cuando docker levante mi archivo.
Mi archivo compose.
De este en este servicio que haga todo eso no cree una tabla una base de datos de postgres crea la tabla y le inserta data.
Si yo probara mi conexión después de que yo levanté mi archivo.
Después de que yo levanté mi contenedor yo voy a poder entrar a esa tabla y esa base de datos y ver todo corriendo.
Entonces eso es para el usuario.
Es para el de productos y en el último que es el de órdenes.
Pues también tienes este lo mismo.
Es básicamente lo mismo.
Crear bases de datos de postgres y crear tablas.
Este crear crear toda esta información.
Sus tablas y meterle data.
Entonces vamos a ver cómo con postgres.
Para eso ocupo yo un cliente.
Sí para yo poder ver que esas tres tablas.
Esas tres bases de datos estén ya creadas.
Va entonces lo que yo necesito hacer para corroborar eso.
Una vez que yo tengo mi archivo docker compose.
Yo me iría a la ruta de donde se encuentra ese archivo para hacer eso.
Aquí se empezó a alentar un poquito la máquina.
Pero bueno no es más que tenerle un poquito de paciencia.
Aquí en la parte de descargas que es donde les decía que está la ruta.
Me voy a ir hasta donde está mi archivo docker compose.
Sí y yo me traigo la la la el pad y entraría.
Entraría a esa esa carpeta y haciendo eso yo ejecutaría un comando que se llama docker compose.
Sí esto está.
Es así estaría ejecutando este comando docker compose y al hacerlo este docker en automático me estaría creando la la la.
El volumen las imágenes y estaría agarrando este archivo de acá que se tiene y estaría básicamente ejecutando todas estas instrucciones.
Entonces al hacer eso me va a crear un contenedor con todos estos software empaquetados.
Y si te fijas aquí también viene la parte de Kafka y lo de su equipo que es lo que les decía que ocupa.
Entonces ahí también me va a estar seteando sus puertos demás.
Y yo con esto también incluso voy a tener Kafka instalado para que me pueda hacer un poco de recorrido.
Y yo con esto también incluso voy a tener Kafka instalado para que yo lo pueda ocupar.
Entonces para hacer eso una vez que yo ya ejecuté este comando al hacer este comando.
Todo esto ya no se hace porque ya se ya se hizo pero se los dejó ahí también en la presentación para que cuando ustedes ejecuten eso se va a generar aquí este contenedor.
Y entonces ahora sí yo ya pueda seleccionar ya sea uno por uno o todos.
Y al darle yo aquí en el botón de iniciar.
Y este me va a estar me los va a estar levantando y se va a poner en verde cuando ya estén todos levantados todos corriendo.
En este caso si te fijas yo ya tengo varios.
Tengo Kafka corriendo en el puerto 9092.
Tengo tres bases de datos corriendo en diferentes puertos diferentes puertos que le fui dictando.
Acá en cada en cada configuración yo teniendo eso yo puedo comprobarlo.
Si por ejemplo mira aquí por ejemplo aquí está habiendo algo con Kafka habría que ver si no lo podemos parar y lo volvemos este lo podemos volver a ejecutar.
Pero bueno ahorita Kafka no es el que menos me importa ahorita lo que quiero es que porque se pruebe es la parte de la conexión con la base de datos.
Aquí ya lo de probar conexión.
Sí y aquí este bueno me está pidiendo un un driver un driver.
Entonces eso está bien si a ustedes también les aparece hay que descargarlo.
Hay que darle en descargar.
Y se tiene que descargar ahí la conexión perdón el driver y una vez que esté descargado ya la prueba de conexión debe ser exitosa.
Entonces si ya le das en terminar.
Te aparece esto.
Y ya teniendo aquí la base la conexión vas a ver los esquemas vas a ver las tablas y si te fijas aquí va a estar la tabla de usuario que tú le vas a poder hacer ya un query por ejemplo un select.
Aquí le das select le das copiar a la consulta.
Y este aquí voy a ejecutar un SQL.
Aquí tengo el cliente es lo de menos tú puedes ocupar pgasmin o el que tú te acomodes para conectarte a las bases de datos y bueno yo aquí si ejecuto ya me va a dar la data que yo cargue que es la que está contenida aquí en este archivo de DML.
Esta data que está aquí ya está cargada porque ya la cargó.
Adelante.
Este lo vamos a volver a repetir pero si quieres este.
Lo podemos ir haciendo ahorita como para que estos digamos la parte de cómo se configura nuestro ambiente o sea ustedes todo esto ya lo tienen configurado yo ahorita se los estoy mostrando para que.
O sea ustedes ya no lo tendrían que hacer porque ustedes ya lo tienen lo único que lo único que podrían hacer es corroborar que si este levantado todo y para eso pues son los pasos que acabo de hacer no.
Entonces este no sé si alguien tuvo también problemas en en llegar a este punto o si quieren que lo repasemos sin problema.
Sin problema.
Sin problema.
Básicamente.
Bueno les explicaba la parte de.
Les explicaba la parte del este.
De los archivos no.
A ver dame un minutito por favor.
No me tardo.
No se.
Listo.
A ver.
Entonces este les explicaba de este archivo del local con post este.
Aquí se ve aquí viene la la forma de cómo vas a crear en este contenedor.
Varios varios productos en este caso un primer producto es el de postgres para la base de datos de usuario luego viene la otra base de datos de postgres.
Para para el de productos y luego viene el de postgres para el de órdenes.
Va.
Este y el otro es el de Apache Kafka.
Y el de su quita.
Entonces este.
Este Apache Kafka y el de su quita.
Este no es tan detallada la explicación porque bueno literal nada más es configurarlo y ya porque Kafka nada más lo vamos a ocupar.
Para lo del bus que les explicaba para para que solamente nos ayude a propagar los eventos que ocurren en el config repo y propague los cambios.
Los que sí vamos a prestarle un poquito más atención son a los de los de postgres explicando el de usuario el de producto y el de orden ya quedan por default igual aprendidos.
Entonces para que tú corres este archivo de no que el con post.
Pero bueno se llama Docker.
Compose.
Y cuando tú haces eso en automático aquí te van a empezar a descargar todo lo que necesitas.
Y cuando tú haces eso en automático aquí te van a empezar a descargar todo lo que necesitas.
Y cuando tú haces eso en automático aquí te van a empezar a descargar todo lo que necesitas.
Y cuando tú haces eso en automático aquí te van a empezar a descargar todo lo que necesitas.
Y cuando tú haces eso en automático aquí te van a empezar a descargar todo lo que necesitas.
O sea va a ir ejecutando todas estas instrucciones y se traduce a que te va a generar aquí este justo este contenedor va.
Cuando tú seleccionas el contenedor ya sea un producto en específico o todos y lo levantas.
Te va a aparecer así en verde y te va a decir ron y corriente.
Cuando tú ya tienes esa parte corriendo tú con el castorcito bueno con cualquier cliente que quieras.
Puedes crear ahora una conexión para probar que en efecto tengas este una base de datos para producto para usuario para orden.
Va en este caso yo hice la de usuario la voy a volver a hacer entonces la voy a la voy a eliminar.
Para bueno voy a hacer otra.
Voy a hacer ahora la de productos va entonces para eso aquí en mi cliente en este caso es de Vivo pero te digo tú puedes usar PGA admin o el que tú quieras.
Y la única lo único que cambia es la forma en crear las conexiones.
Yo voy a crear una conexión para la de productos va entonces yo creo un postgre una base de datos de postgres.
Este el host es localhost la base de datos la base de datos la encuentro aquí todas esas todas esa información de conexión la vas a encontrar acá.
Entonces tú ahorita quien el de productos que es el que me quiero conectar voy a utilizar product ms y product debe como contra como credenciales no vas a ocupar el usuario.
Y en la base de datos y el paso entonces acá le digo que estoy en el puerto localhost en la base de datos es es esto debe.
El usuario que voy a ocupar es este.
Y la contraseña es 1 2 3 4 5.
Sí ahorita que yo me conecte me va a dar un error le voy a dar probar conexión y no me debería dejar porque porque yo no cambié el puerto.
Lo hice para que se ilustra también el uso.
Entonces el puerto en el que yo estoy es en el 54 33 el anterior fue el 54 32 este es el 54 33.
Entonces si lo cambio.
Al 33 va la base de datos es esa el usuario es ese la contraseña es 1 2 3 4 5.
Y con eso ahora sí la la la conexión se debe generar de forma éxitos.
Yo le doy ok y yo le doy terminar.
Sí aquí ya se crea la base la conexión también al producto.
Ahora que quiero corroborar.
Yo lo que hice con Kafka digo con post de con Docker fue decir que me cree esto no le fui diciendo créame la base de datos.
El usuario lo que quieras y le fui diciendo que me cree los.
Estas tablas y no sólo que me cree las tablas sino que me cree la información por default.
Por ejemplo el usuario va también le hice lo mismo para la de producto.
Si yo le doy a quien open file ahora ya vi lo de usuario ahora voy a ver lo de lo de lo de producto.
Para eso me voy a la de la de producto.
Al DL y al DML va en este caso voy a ver lo de los este.
Lo de lo del DML.
Para ver qué data inserte y si te fijas son tres productos.
Yo lo que quiero corroborar es que estos tres productos ya estén ahí en esa tabla de productos.
Entonces ya me conecté ahora voy a meterme a la base de productos aquí veo.
Los esquemas.
Y veo que está el esquema public veo las tablas.
Y aquí en productos.
Yo le doy generar ese cual.
Voy en select.
Sí y yo me puedo abrir un nuevo bueno creo que incluso aquí dentro de este.
Me va a permitir ejecutar esa consulta.
Voy a generar ahora la tabla de productos.
Y le voy a hacer un select.
Y si no no me deja porque.
Porque creo que tiene que ser en otra en otra pestaña.
A ver déjame lo traigo.
Sí me dice incluso que no existe porque este es como que el ambiente de productos.
Entonces voy a crear.
Sí sí también.
Digamos para tenerlo más este ordenado lo voy a abrir en un nuevo.
Es básicamente nada más por eso.
Entonces este aquí le puedo dar.
Un nuevo.
Y también a mí se me hace un poco complicado manejar los botoncitos porque como que se cambian.
Un nuevo script de base de datos.
Sí bueno.
Ya para que no me deje.
Tanto rollo me cambio nada más desde aquí.
Me cambio producto y ya estando en producto este.
Ya puedo ejecutar su consulta.
Y ahí te si te fijas ahí me crean a lo bueno ya tengo los tres productos que yo di de alto.
Esos productos te fijas son los que corresponden con los que yo agregue aquí.
El de 15 75 el de 20 50 el de 50.
Y aquí el de 15 75 el de 20 50 el de 10 99.
Va entonces eso es como que la forma en la que se para que se ocupa docker.
Para que se ocupa el docker desktop el compose y de esa forma estoy viendo cómo se está creando mis.
Tablas con mi con mi información inicial o por default.
En cada una de las tablas estas bases de datos cada una es independiente porque corresponden a un micrófono.
Y es que es la base de datos de un micrófono.
Y es que es la base de datos de un micrófono.
Y es que es la base de datos de un micrófono.
Y es que es la base de datos de un micrófono.
Y es que es la base de datos de un micrófono.
Y es que es la base de datos de un micrófono.
Y es que es la base de datos de un micrófono.
Y es que es la base de datos de un micrófono.
Y es que es la base de datos de un micrófono.
Tenemos que también se ocupa Kafka que es el que ya vimos que también ya se instaló en nuestro contenedor.
Y también tenemos Git.
Para corroborar que tenemos Git aquí le picas en buscar.
Te va a aparecer el bash de Git si quieres pues lo puedes abrir.
No es más que verificar que esté instalado ahí Git.
Ahorita les voy a pasar las URLs para los repositorios que estaremos ocupando.
Y la idea es bajar cada uno de los repositorios para que hagamos nuestras prácticas de forma local.
Para esto tendríamos que crear una cuenta temporal.
Ahorita vamos a dar el tiempo para que cada quien cree su cuenta en GitHub.
Les doy acceso a los repositorios y que puedan descargar los...
Los repos.
Ahorita haremos esa parte.
Ya que tienes también acceso a Git.
Todo esto de los herramientas de Spring Cloud.
Que básicamente son librerías que se van a ir instalando en cada microservicio que ocupemos.
Estas librerías pues las vamos a ver en los microservicios internamente.
Y bueno con eso terminamos de ver todo el ambientado de nuestra cuenta.
De nuestro ejercicio.
De lo que vamos a estar ocupando.
Solamente vamos a estar ocupando esas partes.
Haciendo los repasos generales.
Ocupamos Docker Desktop.
Java 17.
Tele-JID en su versión Community para líder de desarrollo.
Ocupamos Spring Boot.
O vamos a ocupar Spring Boot, Spring Cloud y Maven como librerías.
Vamos a estar ocupando PostgreSQL como base de datos.
Un cliente.
Vamos a estar ocupando Kafka que también ya vimos que se instaló en Docker Desktop.
Con el contenedor, el mismo contenedor de PostgreSQL.
Ya vimos que tenemos Git.
Y estas librerías de Spring Cloud.
Son las que vamos a ir metiendo en cada microservicio.
A medida que los vayamos ocupando.
¿Va?
¿Alguna duda con el ambiente de configuración que se ocupa?
¿Qué se ocupa?
¿Qué se ocupa?
¿Cómo se instala?
¿Esta?
Claro.
Esa es el Bash de Git.
Lo único que tienes que hacer es buscar aquí.
Escribes Git y te va a aparecer Git Bash.
Igual lo ejecutas como administrador y te va a aparecer.
Sí.
Sí, no hay de qué.
Entonces, esta es la parte de los...
De los...
De los ambientes.
El ambiente.
Entonces, ahora sí vamos a crear una aplicación con Spring Boot.
A ver, solo un minuto.
Un minutito, por favor.
Vale.
Va, entonces dice, crear una aplicación Spring Boot.
En este primer día, se va a crear desde cero el microservicio de usuarios.
Aquí también hay un error que de hecho ya voy a ir corrigiendo.
Porque no es el de usuarios.
Es más bien el de productos.
Ah, bueno.
Vamos a usarlo aquí de usuarios.
Porque ya me acordé.
Aquí en la presentación se describe usuarios.
Pero nosotros en la práctica vamos a usar productos.
Ok, sale.
Y luego dice...
Este microservicio se encargará de gestionar los usuarios del sistema.
Permitiendo la creación de nuevos y la gestión de sus permisos.
O sea, básicamente vamos a estar haciendo un CRUD sobre la entidad de usuarios.
Aquí es lo que se describe.
Nosotros en la práctica, yo lo voy a hacer con el de productos.
Para que tú tengas, digamos, las dos formas de hacerlo.
Vas a poder levantar el de usuarios.
Siguiendo lo que viene aquí en la presentación.
Y lo que yo pongo en la...
Sí, en la máquina.
Lo que se va grabando en la presentación.
Yo voy haciendo el de productos.
Va.
Entonces, así se cumplen los dos.
O se cubren los dos, mejor dicho.
Y el de órdenes también lo vamos a ver todos juntos.
Y si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si no, si                

on 2023-08-31

language: ES

                  WEBVTT
Pero bueno, a ver si quieres intentarlo, dale, dale.
Bien, entonces, a ver, entonces vamos a dejar los otros cinco minutos del pomodoro 1230,
1242. Nos volvemos a conectar, ¿va? Ya sería el último corto, después vendría ya el
largo. Y este, y revisamos, y bueno, ya continuaremos
la idea sería que fuéramos descargando, o sea, al final tenemos que descargarlos todos,
pero ahorita para el día de hoy vamos a descargarnos nada más el de user service y este, el de
product service y el de orden service, por favor.
Entonces para descargarlo solamente hay que darle, hay que entrar a la, a cada uno de los
repositorios, o sea, yo lo que hago es darle clic derecho a abrir en una nueva pestaña y se me va
abriendo. Entonces cuando ya estés aquí adentro en user service, este, vas a ver una, digamos,
como un Dropbox donde dice code, aquí en la parte de HTTPS ves, ves este enlace, le das copiar,
sí, y por ejemplo utilizando git bash, por ejemplo puede servir ya que lo tenemos ahí abierto.
Hay que, primero hay que meternos a la ruta en donde quieres que guardemos el repositorio. Yo les
creé, según me acuerdo, una carpeta que se llama repositorios y se encuentra aquí en disco local,
se van a usuarios y luego se van a noble proj y aquí adentro hay una carpeta que se llama
repositorios. Entonces lo que pueden hacer es copiar este pad, sí, venís aquí al git bash o la
terminal, no hay problema ahí, y entren ahí al, a la url, bueno, al pad que acaban de pegar. Como
esta tiene espacios, ah bueno, no tiene espacios, la pueden poner así en comillas simples o sin
comillas y el chiste es que ya puedan entrar aquí a la ruta, va. Entonces una vez que ya estén allá
adentro, este, aquí ya pueden ejecutar este comando de git clone, git clone, y todo esto según entiendo
a ver, voy a ver a tu máquina, ah, pero te digo que
no, quieres compartir o quieres que te lo repita a los pasos y los vas a seguir
las comitas simples, sí, a ver, intentarlo con las comitas simples
va, los demás si ya terminaron de copiar todos los repositorios, ayúdame también a ejecutar
este comando porfa, que es git, espacio, config, espacio, guión, guión, list, porque necesitamos
ver que haya un username y un username y email este configurado, perfecto, sale y
y bueno, ya que ya que tengan los repositorios, ayuden a ejecutar este comando git config list
y déjenme ver quién ya lo tiene, básicamente en el config list debe de aparecer hasta abajo
un username y un username y email, nada más opción es que si tenga un valor, por favor
y en tu problemas en en contra de esas propiedades
adelante dime en dónde, a ver déjamelo comparto acá, aquí lo voy a compartir
git config, así
no, ahí nada más fíjate si en el username al final dice user.name, user.email
que tenga un valor, de hecho tiene que decir capalata no sé qué
cuando ejecutaste el git config list te va a dar una serie de propiedades, hasta abajo dice
user.name y debe de venir un valor, ok y para el user.email corre, corre, ok sale entonces ya
que tenemos eso configurado ya hay que bajarlos todos los repositorios que son el de producto,
el de usuario y el de orden, va, entonces eso
eso ya nada más lo voy a ilustrar así de forma rápida, básicamente lo que hicimos aquí en el de
usuario hay que hacer lo mismo pero en el que se llama producto y en el que se llama orden,
es decir lo abro por ejemplo el de producto igual me va a aparecer aquí en la parte que dice code
HTTPS le doy copiar a ese enlace y aquí en el bash obviamente nada más me regreso un nivel,
ah no ahí estoy en repositorios ahí le doy otra vez git clone, pego la url y me lo descarga,
eso mismo para los tres repos y listo ya que los tenemos ahí abiertos,
los vamos a mantener ahí un ratito en lo que voy a ir explicando cómo se crean los proyectos,
va, entonces aquí en la diapositiva pues nos dice que yo voy a crear con spinq initializer
estos proyectos, este proyecto y le voy a setear esta data o esta metadata,
va, la metadata nos ayuda a este pues a describir el proyecto, entonces este
yo voy a ir creando por ejemplo en el grope voy a poner com.att que hace referencia pues
estamos trabajando aquí en AT&T va entonces si te fijas aquí en el grope tú puedes escribir
AT&T va en el artifact pones user service en este caso nosotros estamos viendo el de producto le
pones producto service si te fijas ahí solito en automático ya te autocompleto todo lo demás lo
vas a dejar igual solamente si acaso puedes cambiar la descripción yo en este caso copio
esta que tengo acá la pego acá el nombre del paquete lo único que hay que cerciorarse es
no utilizar este la parte de bueno aquí es de productos no hay que ocupar esto no hay que
yo le doy generar y me va a descargar ya un paquete nada más que ahí
este está mal
este producto está mal creo que es todo esto me lo quito me equivoqué porque no elegí maven
no me había fijado no elegí aquí se tiene que elegir yaba aquí se tiene que elegir maven aquí
la versión de spin que está bien esa porque de todo lo vamos a cambiar ahora sí ya con eso
cuando se genera se te va a abrir un archivo bueno se te va a descargar un archivo que es un zip y
ese proyecto trae digamos todo lo que es un proyecto de spring el nativo así cero desde cero va un
proyecto desde cero y estos proyectos ahorita lo ilustre nada más para que vean cómo yo lo hice
pero bueno al final ya el proyecto que se genera es el que yo voy a abrir por eso les pedí a
que descargarán el archivo es por ejemplo el de producto cualquiera de los tres de ese producto
usuario orden tienen la misma estructura entonces cuando y tú lo abres en intel y se te va te va
a abrir este este proyecto así con estas mismas estructuras de carpetas te va a poner el nombre
que le diste te va a generar estas carpetas te va a generar un archivo pom que es muy importante y
lo vamos a ir repasando te va a generar un ritme todo esto no el archivo importante que
vamos a repasar ahorita es el pom entonces todo esto que fuimos dando de alta aquí en spring
inicializer que de hecho también se ve aquí en la presentación es decir el grope el artefac en
todo eso viene dentro de nuestro archivo pom.xml es un pom xml porque yo elegí maven si te fijas
aquí viene como que el tema de con maven porque está ocupando maven para como gestor de paquetes
y maven ocupa archivos xml diferente a gradle por ejemplo que ocupan los json entonces esto fue
meramente por por puro clasismo porque lo he hecho así mucho tiempo pero tú puedes estar elegido
gestor de paquetes que ocupes entonces yo casi estoy seguro que ustedes también han ocupado
maven porque es como es el pionero en esto de crear gestor de paquetes con spring entonces
bueno todo esto que se fue dictando aquí en la metadata que se ve aquí en la presentación se
va viendo en el pom por ejemplo el grope que es con .att o at&t aquí lo tienes
ahí vas a tener también la parte del artefact tienes el name se acuerdan de aquí nada más voy
a dejar esta propiedad así en azul se acuerdan que les decía que con eureka hay una propiedad
que se ocupa mucho y es el name bueno este es el name del que se le da al proyecto en el pom que
es diferente a la que se le da en el archivo de configuración pero básicamente nos referimos
a esa propiedad al nombre del microservicio aquí tiene una pequeña descripción de propiedades
tiene llama como versión 17 que es la que vamos a estar ocupando tiene la biblioteca de spring
boot la versión 26263 que es la que aquí dicta que descarguemos sale tiene todo esta parte va
entonces esto es lo que se va creando si nosotros creamos eso desde spring inicializer le damos
descargar nos va a generar este archivo este este proyecto esta estructura de proyectos
aquí obviamente yo la pongo ya ilustrada directamente desde el repositorio que me baje
porque bueno para que ya se vean las otras dependencias que le fui agregando que fuera
aquí adentro también hay una configuración que se agrega para evitar que corran las pruebas
con detalle este es el archivo pom que se encuentra en nuestro repositorio del microservicio
product service va entonces eso es básicamente esta parte aquí tú creas el proyecto y es lo
que te decía te va a generar una estructura de este tipo va en este caso tienes el product
y el service hasta llegar a la aplicación principal que es la que tiene el método
me entonces esa también la podemos encontrar nosotros que está en main ya va con me tientí
entonces para eso aquí básicamente es lo mismo en la raíz del proyecto buscas la carpeta source
el paquete y si te fijas aquí viene nuestra clase principal va viene nuestra clase principal
está decorada con este método me tiene este a esta anotación que es la que ya habíamos repasado
que nos permite identificar esta clase como una clase de springboard application es decir
que se va a autoconfigurar se va a autoconfigurar entonces yo no me voy a pelear ahí con problemas
intele y otra cosa es que tiene una y tiene un mecanismo para que detecte lo que son estos
métodos mains dentro de las clases y tienen este triangulito si tú le picas ahí ya cor solito te
corre toda la aplicación va te corre el proyecto entonces bueno esta es la parte de cómo se crea el
hasta aquí alguna duda un comentario perfecto super vale entonces aquí vamos siguiendo la demo
el objetivo de crear el objetivo es crear un cruz mejor dicho en cada uno de los tres
microservicios es decir nosotros vamos a tener un cruz de usuarios vamos a tener un cruz de
productos y un cruz de órdenes y ese cruz se llama así por las siglas del inglés que vienen a ser
un crea un read un update y un vídeo que son básicamente las operaciones de lectura escritura
actualización y borrado para alguna entidad en este caso usuarios entonces para nosotros hacer
este cruz que básicamente se va a exponer como una pi nosotros vamos a crear en points en este
caso vamos a crear cinco en points porque cinco porque el get que viene a ser el read se acostumbra
a crear dos por default uno que te de todo todo a la todos los registros de esa entidad de la tabla
de usuarios y también te de el usuario por id uno en específico pasando el id va entonces son
dos de get y los demás pues ya es el de el post es el que nos va a ayudar a hacer el alta del nuevo
usuario el put la actualización de algún de alguna información de un cierto usuario pasando el
id y el delete que es el borrado del usuario también pasando el id va entonces estos son los
en points que vamos a estar mapeando y que vamos a estar creando en cada uno de los microservicios
bien entonces aquí nos dice cómo vamos a crear el los en points para dar de alta usuarios y para
obtenerlos va es decir el post y el get y bueno aquí nos va a ir describiendo este cómo se va a ir
dando de alta y para que sirve cada una de las clases nos vamos a ir detallando este
una por una va entonces aquí te dice básicamente que tienes que crear los siguientes paquetes esos
paquetes como les digo yo aquí en este microservicio que ya les estoy mostrando ya están hechas y lo
hice así para que ustedes ya puedan ver cómo queda el producto final y esto ustedes lo van a
retomar cuando les toque hacer el de usuario y el de órdenes que es básicamente acabando este este
micro pues básicamente aquí lo que te dice es que tú te pares en el paquete raíz en at&t user
service o product service sí y tú le des bueno crees los crees los siguientes paquetes que
básicamente es crear carpetas control el modelo de teóropos y tal y sea va entonces voy a crear yo
por ejemplo un examen controller 2 como para ver cómo ilustrar cómo se crea el paquete
simplemente le das mío eliges package y ahí pones el nombre de la carpeta que quieres o sea yo por
ejemplo voy a crear control ahí ya me marca que existe porque ya existe pero voy a poner
ese paquete si tú te fijas se crea como una carpeta los paquetes al final son eso son carpetas
entonces esa es la forma en la que tú vas creando los los paquetes yo aquí los voy a ir quitando
porque no tiene caso que los guarde pero bueno esto es la forma en la que crees el paquete de
son los paquetes que vamos a estar ocupando nuestras capas por así decir para qué sirve cada una bueno
el control nos sirve para almacenar las clases controladoras que van a manejar las
peticiones de los en pues es decir que ahí en esa clase controller tú vas a encontrar
mapeados estos en pues va para cada entidad la clase modelo de almacena la clase el modelo
básicamente en este caso aquí se habla del modelo de usuario nosotros aquí en nuestra tabla en nuestro
servicio de productos en la carpeta modelo pues vamos a ver nuestro modelo de producto ahorita
vamos a ver cómo se crea todo esto ahorita nada más ilustro que contiene va para qué nos sirve el
DTO básicamente son las clases que nos permiten pasar la data desde que crea desde que llega una
petición hasta que se almacenan la base de datos va entonces ese DTO lo vas a encontrar al mismo
porque porque aquí es donde llega la petición entonces déjame acepto a una persona
entonces tú aquí por ejemplo tienes este los los DTO si te fijas ahí lo subrayo lo selecciono y se
colorea en donde se está ocupando entonces básicamente esos DTO nace conforme también
hace el modelo lo voy a ver nada más como para que lo veas de reojo ahorita y si te fijas es
muy similar a nuestra clase modelo solamente que esto no sirve para hacer persistencia simplemente
es para pasar información de un request hacia un modelo va este para eso sirve ahorita vamos
a ir viendo cómo se crea cada clase el repositorio es el paquete que nos permite utilizar la interfaz
y ser repositori que es la que va a interactuar con la base de datos nosotros con las librerías de
jpa vamos a poder mapear a través de interfaces este los el crud tan tan sencillo entonces en
el repositorio tú te vas a encontrar esta entidad que es el producto repositori que básicamente nada
más es extiende extender del repositorio de jpa y con eso se acuerdan de la definición de spring
spring boot spring boot nada más mapeas de una forma bonita de una forma de una forma que que
te pide que mapeas spring y en automático te hace todo no aquí tú ya tienes este todo un crud aquí
tú ya puedes ocupar todos los métodos para hacer alta baja consulta simplemente con estas líneas y
diciéndole de qué entidad quieres que sea ese crud y obviamente este jpa repositori hace caso
de lo que viene aquí en este application que ahorita lo vemos a detalle todavía no hemos hablado
de él ya lo habíamos hablado al principio pero a detalle de este no pero si te fijas este es un
archivo de configuración de los que platicábamos al inicio y aquí se ve cómo viene la base de datos
la conexión string entonces ese conexión string es el que está ocupando nuestro repositorio para
después de esto viene la parte del servicio que nos sirve para prácticamente ser la lógica
entonces ese paquete se encuentra aquí en service y tiene dos clases en la interfaz que nos define
el que se va a hacer que básicamente son los métodos de los cruz el get all el get by id
el create el update del delete y la implementación que nos dice cómo se va a hacer cada uno de esos
métodos que no es más que utilizar el concepto de inyección de dependencias si y estar ocupando
por ejemplo un get all productos usar el repositorio que es este se está creando una instancia ese
repositorio y como te decía ya tienen los métodos ya guardados aquí yo no le definí ningún método
ya los trae por defao no aquí tienes un find all un find by id vas a tener también un delete un
entonces esto es este básicamente el cómo funciona lo vamos a ver a detalle clase por clase
ahorita nada más estoy como repasando que contiene cada cada este cada paquete va
y si te fijas en la siguiente diapositiva te dice que así quedaría la estructura no el mapa
tu clase me en tu paquete controller con su clase tu paquete model con su clase tu paquete
de t o con su clase tu paquete repositor y con su clase tu paquete service con sus clases
que son básicamente las mismas que nosotros ya fuimos revisando tu clase tu paquete principal
el controller su clase el de to su clase el modelo el repositorio el servicio y tu clase
bueno incluso aquí en el mapa se ve el resource
en los orces y otro chivo muy importante el pom sale hasta aquí hay alguna duda de cómo se
piensa la aplicación más o menos da a entender qué es lo que se hace en cada en esta aplicación en
este micro servicio de producto o en esta aplicación de producto hola hola todo bien perfecto entonces
iguales y dicen que repasemos las cosas no hay ningún problema
entonces bueno esto es como la embarrada de qué es lo que lleva cada clase cada más bien cada paquete
y ahorita vamos a ver en detalle cada clase sale entonces listo ahora sí aquí es donde te dice
te va a ir diciendo cómo ir creando cada clase en cada paquete y para que se ocupa entonces
todo eso lo voy a explicar a través de este diagrama
qué bueno este diagrama es ya más bien este ya más bien la parte de agregarlo con este
con la iniciativa de la nube entonces esto no voy a no lo vamos a
no lo vamos a ver todavía hasta crear los microservicios y bueno nos vamos a querer
nos vamos a quedar entonces en esta parte vamos a ver con detalle ya la aplicación va el producto
para que la podamos este desarrollar en el otro en el otro en el otro micro
entonces esta aplicación de producto ya vimos cómo se creó con speng initializer la abrimos
identificamos un archivo importante que es el pom en el pom nada más hay que serciorarse de que lo
tengas igual que aquí es decir tienes que tener bueno yo estoy en una rama que se llama feature
first day eso es otra de las cosas que tal vez también tendríamos que ir hablando en los
repositorios que les pasé producto orden usuario si te fijas existen tres ramas bueno de hecho en
todos los repositorios existen tres ramas existe tu rama main tu rama develop y tu rama feature
first day esta rama feature first day es la que de la que ustedes van a tener que crear una nueva
rama con sus iniciales para cada microservicio y ahí es donde vamos a estar trabajando esa esas
ramas que van a ir creando ustedes con su inicio con su inicial son las que van a estar este
desarrollando en este caso por ejemplo el de producto que ya está terminado la rama de feature
first day este ya está completa ya tiene todo pero por ejemplo la de usuario la de órdenes no tiene
completos todos los paquetes todas las clases demás no entonces el objetivo del ejercicio del día de hoy
cuando ya terminemos va a ser hacer el cruce de usuario bueno completar el cruce de usuario y
el de órdenes basándose en el de producto va ese es el objetivo entonces en este producto por eso
hago alusión de la rama porque yo estoy igual en la rama de feature first day y que es esta y en
esta estoy creando este pues esto entonces estoy creando aquí el el la estructura la definición
del proyecto con maven perdón con spring inicializer la cree obviamente utilizando maven y bueno se ve
toda la metadata que fui dándole de alta no le fui creando su group id el artefacto el name el
description sus properties de la versión de yaba la versión de spring boot agregué dependencias
como spring web no agregué spring starter boot este para que sea spring boot agarré la parte de
jpa agregué el driver de postgres y estas configuraciones adicionales para que no tomen
cuenta la del testing unitario va una vez que yo tengo hecho esto yo con maven aquí tiene
intel y tiene incorporada una digamos un maven tiene maven incorporado by spring
este del y entonces yo con eso puedo hacer la descarga de paquetes
ya sueno la este ya sueno la alarma pero vamos a vamos a dar un así rápido unos cinco últimos
cinco minutos porque este ya es el último descanso digamos es el descanso largo pero a ver ahorita
ahorita lo hablamos de esto entonces yo teniendo maven aquí incorporado puedo hacer la
sincronización y al hacer al presionar este botón me va a estar descargando los paquetes
qué paquetes va a descargar maven en automático va a reconocer que se trata de un proyecto maven
porque existe un pom entonces al existir un pom maven su naturaleza es venirse a este archivo y
va a ir leyendo todas las dependencias que tienes aquí tu dadas de alta y las va a ir a buscar en
un repositorio global que se llama el maven repository y va a empezar a buscar estas dependencias y las
va a descargar en tu proyecto las va a las va a ir descargando y se van a ir guardando en una
carpeta que se llama external libraries va pues si te fijas aquí todas estas librerías ya las fue
descargando de maven esto para qué sirve para que el día de mañana que tú quieras ocupar un no sé
una librería que te transforme o que te ayude a manejar validaciones en json o crear json o no sé
algo que te manejo de fechas bibliotecas externas este las puedas ocupar por ejemplo yo las voy a
usar para manejar este la persistencia con jpa y mañana que vayamos agregando más
miembros de la familia de spring cloud más librerías aquí las vamos a meter no para que
podamos utilizar feinclient eureka el config server todo eso lo vamos a ir agregando aquí en maven
va en las dependencias entonces esto es la esto es como funciona un pom así como a nivel rápido
rasgo a grandes rasgos y bueno en específicamente cómo funciona el pom de nuestro microservicio
de productos va entonces a ver aquí es que fíjense que me cambiaron la jugada porque yo
estaba acostumbrado a dar el curso de 8 a 4 va entonces ahorita ya se hizo se me cambia porque
ya empezó a las 9 y ya se traslapa una hora que es no sé en mi curso anterior a estas horas ya era
la hora de la comida quieren que hagamos ahorita mejor la hora de la comida demos en la hora de
receso una hora o damos el descanso largo y después tomamos otra sesión de 45 minutos y
después haríamos la hora de comida como les funciona más
si
ok la hora de la comida en la tienda 2 a 3 perfecto entonces podemos hacer esto miren
podemos campechanear podemos seguirnos ahorita de aquí hasta las 2 y porque ahorita ya se ya se
ya se tendría que tomar el pomodoro el descanso largo de 25 minutos que les parece si hacemos esto
nos seguimos de aquí a las 2 a las de 2 a 3 la hora de la comida y después de la hora de la comida
seguimos con los pomodoros pero en uno de esos en vez de descansar 5 minutos hacemos el descanso
de los 25 va entonces a vientos perfecto entonces vamos a darle de aquí a las 2 continuamos y
tomamos ya la hora de la comida salival entonces este va entonces esta es la parte del pom sale
este es el fichero que se crea que se ocupa con maven sale bueno después de este archivo
otro archivo importantísimo es el application yame este archivo es el que les decía que es
el archivo de configuración este archivo se puede llamar application yame también lo van a encontrar
como aplicación punto properties o incluso hay otros que se llaman bootstrap punto llame va son
archivos que le brindan a tu proyecto configuración por ejemplo el ejemplo creo que más común es el
de la base de datos simplemente yo al declarar un archivo application llame en la carpeta
resources la configuración de spring boot en automático va a entender que este es un archivo
de configuración y todavía más aún más inteligente va a entender que si tú creas esta estructura de
propiedades en este caso es bien data source url y username password va a entender que cuando
tú estás trabajando con un modelo basado en persistencia de jpa que su biblioteca su framework
interno hivernet toda esta parte cuando tú crees repositorios si cuando tú extiendas clases de
este jpa y pases el modelo y demás esto en automático la configuración de spring boot
va a entender que se tiene que conectar a una base de datos que se llama product debe en el
puerto 54 33 del host local con el username y con este password todo eso lo va a entender en
automático si cuando eso suceda ya te va a ver aquí te va a brindar de ciertos métodos que son
suficientes para hacer un cruz va eso es como funcionaría la parte de la configuración de base
de datos ahora esta esta conexión string de donde la sacamos si se acuerdan que ya hicimos
un ejercicio en donde nos conectamos a la base de datos de cada de cada uno de ellos no de cada
entidad y si se acuerdan todo eso nació de este archivo que teníamos que se llama docker compose
aquí adentro ustedes pueden ver o repasar y extraer las conexiones aquí tienes por ejemplo
el password y la base de datos también tienes el puerto si con esos tienes aquí todo mapeado para
que tú puedas conectarte aquí en la base de datos va y bueno eso eso es con respecto a la base de
datos pero el propósito o sea lo que trata de ilustrar es el propósito de este archivo este
digamos de esta forma sirve para que sea tratado como un microservicio no esto es para que lo
lo tengan identificado esto es un microservicio así se ve va entonces este en específico es
nuestro microservicio de productos microservicio de
de microservicio de productos
sale entonces este
listo hasta aquí alguna duda con estos dos archivos más o menos se ilustra de como para que sirven
a grandes rasgos
adelante
de cual
es para este yamen si si es muy parecido de hecho ambos son extensión yamen si te fijas es yml
este también es yml es que lo que pasa es que ya mel es este es un formato pues ya cada vez más
estándar universal
ok
si son digamos ahorita si yo lo quitará no no le no le afectaría no le afectaría porque
ahorita nadie lo está ocupando ni siquiera el código pero ahí más adelante vamos a ocupar
estas variables justo en la práctica del config server y el config repo para que nosotros podamos
hacer uso de estas variables ocupamos una anotación que es el value y ese value nosotros ya lo podemos
utilizar en cualquier parte del método aquí no se va a ver porque no hemos llegado a ese punto
pero utilizando ese value vamos a poder utilizar los valores de estas variables
perdóname te entendí de si esta propiedad name tiene que ser igual a cual otra perdón
ok no no no son independientes digamos que ésta es como la el name que tú le das al empaquetado
de tu de tu proyecto pero ésta es la de tu la de la configuración como como dijimos interna
de tu proyecto no esa es una muy buena observación pero si no son diferentes propiedades va
perfecto alguna otra duda
correcto
si si aquí en la práctica tú puedes tener generalmente el tema de microservicios están
empaquetados no en contenedores de doc entonces este son instancias o te conectas más bien a un
grupo de réplicas que vienen metidas dentro de cierto contenedor ahí te facilita mucho
kubernetes y muchos de esos software pero para fines prácticos si son urls diferentes al local
host este te van a exponer una url un puerto un usuario y esas son las conexiones que tú
debes de seguir va perfecto sale y vale alguien alguien más que nutra este ejercicio con sus
preguntas u observaciones también válidas perfecto sale y vale entonces si no hay continuamos
entonces muy importantes esos dos archivos ya que al estar haciendo muchos microservicios
los vamos a estar viendo creo que más que el código de programación es más configuración
pero bueno ok entonces este aquí en la parte de ya entrando a detalle cada una de estas este
paquetes que se ilustran como carpetas contienen clases contienen ciertas clases que hacen un
algo la clase el paquete principal que es el paquete raíz donde está el nombre de tu micro
tú tienes una clase main que se llama como se llama tu tu microservicio un
producto service application esa clase como te decía tiene un código un método main que es
un public static void main que es aquí donde nace todo esta esta es la que ejecuta todo
va esto es muy importante que si estamos trabajando en el framework de spring boot pues la decoremos
con la anotación es príncipe de application para que haga todo lo que incluso aquí te no
dice auto configuración a que todas a ti configura auto configuración funcione estar marcada de esta
forma son de las pocas cosas que te pide spring boot como para que tengas ahí cuidado y todo
funciona y el lidé de intel y si te fijas aquí ya tiene un botoncito que si tú le picas en
automático te dice que si lo quieres correr lo quieres de bugear y le quieres correr la cobertura
etcétera etcétera etcétera entonces este eso es lo que lo que tendríamos va esta clase
de esta clase creo que ya la conocen de otros proyectos no tienen algún alguna duda con esa clase
perfecto va entonces si no adelante
ok no te lo estaba abriendo así
ah listo
ok que bueno que bueno que salió eso
adelante dime
si puede ser que no hayas bajado las dependencias es decir aquí dentro del
pom te va a aparecer un circulito azul o aquí en meiven le puedes picar es este circulito pero
fíjate que también yo lo he notado yo lo he notado en otros proyectos que qué pasa que cuando tú
te aparece como que una notificación que te dice que si quieres cargarlo como un proyecto meiven
o algo así ahí tú le dices que sí y en automático te lo tiene que transformar de esta forma incluso
no sé si se vea aquí en la campanita de notificaciones probablemente y venga lo sí lo he notado fíjate que
si me ha pasado probablemente lo puedas tu ver si si no lo que te recomendaría es volver a salir del
proyecto porque creo que no sé si no te deja incluso descargar los paquetes eso es porque no
lo reconoce como un proyecto meiven hay veces que medio se atonta también intel y entonces lo que
puedes hacer es salir del proyecto y volverlo a abrir y te tiene que abrir una notificación
algo así que te dice algo como tratarlo como proyecto meiven importar no algo así tú le dices
que sí y ya ya te lo tiene que tratar de esta forma si si me ha pasado
ok ok
en abrir proyecto le das file open project y ya te aparece
bien entonces sale entonces esto que explicábamos es la parte
de la clasima y salí bien entonces ahora ya que fuimos creando si se acuerdan del paso anterior
fuimos creando los paquetes que al final se ven como carpetas si lo fijas si te fijas y al final
esos son los paquetes son formas de acomodar las clases en agrupar las clases no es un paquete
es eso es una carpeta entonces aquí las inteligen las va a tratar así y dentro de cada una de ellas
tú vas a ir viendo las este las clases entonces si tú te fijas la clase la primerita donde va a caer
la petición cuando la expongamos este este micro es en el controller si que hago para que
una clase sea tratada como un controller bueno tu folder se llama control va tu clase que se llama
producto debe determinar con la notación controller en este caso yo estoy utilizando un controlador
de productos porque vamos estoy hablando de mi microservicio de products va entonces mi
product controller es estas son de las cosas que les digo que es print book toma como autoconfiguración
si tú me dices que esta clase se llama controller yo sé que es un controlador y él entiende cómo
lo debe de tratar él va a en automático va a estar escaneando tu clase y te va a decir oye te
falta la notación rest controller que onda y te va a empezar a mandando errores no te va a empezar
a ir mandando errores en caso de que no encuentre algo de autoconfiguración eso en lo personal a
mi experiencia también es un problema y es una lata porque luego tú dices pero porque es el
error cierto error y es que uno tiene que entender o tiene que aprender de cómo se autoconfigura cada
cosa entonces eso también es un problemita para mi punto de vista no sobre todo para los que van
empezando dices y a mí me llegó a pasar la verdad sale entonces este tipo de cosas fueron
bueno son vaya alguna mención de que también se tiene que tener cuidado no en este caso si
te fijas esta clase aparte que se decora con el control se decora con el request mapping para
que nos sirve este ricos me pin para que cuando yo tenga mi url local ya sabes 2 puntos locajos
pueda yo poner diagonal products y pueda acceder a todos los endpoints que están definidos en esta
clase y esos endpoints también tienen su propio pad por ejemplo los que ocupan una id en específico
no por ejemplo bueno estos impuestos valdrían la pena revisarlos de acá si te fijas acá este es el
pad base por así decirlo y lo demás es lo que ocupa como parámetro no eso mismo es lo que
estamos definiendo acá en él en la clase de controlador sale estás definiendo tu ruta base
que es esta sale y todo lo demás pues son los los los los endpoints que ocupan el parámetro id va
ocupas esta línea que te sirve para hacer logger interno que no es más que pintar logs si algo
falló tú puedes ocupar el logger hacer un punto log y te va a imprimir aquí los logs que vamos
a ver también la propuesta que trae spring boot spring cloud perdón un mecanismo que se llama
no es más que un servidor que básicamente te permite rastrear errores por por medio de
identificadores entonces vamos a configurar también hay un cliente de si quien un servidor de si quien
y vamos a hacer esto de los logs de una forma más más pero no porque digo los logos ayudan sirven
no nadie dice que no pero este hay otros mecanismos actualmente no para poder monitorear
entonces este después viene la parte de utilizar una inyección de dependencias aquí vamos a
inyectar el servicio de productos este servicio de productos es básicamente este de acá si te fijas
del control fíjate fíjate cómo brinca el colorcito azul se va al product service cuando yo le digo
dime de qué clase es se va hasta acá el controller manda a llamar al service entonces este service lo
manda a llamar porque en el service el product service implementation está toda la lógica que
se ocupa para hacer los cruz ahorita la vamos a repasar también con detalle nada más lo que
quería que vieran es como el controlador manda a llamar a la implementación del service va entonces
de product service y estos auto wiretts que son básicamente pasar en el constructor todos
los clientes que se que se ocupan como dependencias externas no que en este caso es el servicio pues
aquí lo inicializamos y hasta ahí no hay ningún problema y ya empezamos a ver los mapeos de rutas
por ejemplo que nos pide aquí crear la definición o el planteamiento del problema nos permite nos
está pidiendo crear cinco endpoints un get users que es el get all un get user by id no un uno en
específico un post de usuarios un put de usuario por id y un delete de usuarios por id entonces al
hacer eso nosotros tenemos esto tenemos el get mapping esto lo que hace es traerme todos los
productos lo único que hace es consume ocupa el servicio de producto este servicio y manda a llamar
al método get all products yo me voy a la definición de este método aquí lo vas a ver dentro de esta
y si te fijas este de aquí este service implementation también tiene una inyección de dependencia pero con
la capa que se va a encargar de recuperar de los repositorios la información no es un
método de get all products y si te fijas este de aquí este service de get all products
también tiene una inyección de dependencia pero con la capa que se va a encargar de recuperar de
los repositorios la información en este caso es el producto repositorio si te fijas yo me voy a su
definición igual sale y cuá y fíjate cómo estoy parado aquí cuando yo mapeo a la clase que me abrió
va a brincar y se va a ir al repositorio entonces ahí tú vas haciendo la cadenita no el controlador
ocupa el servicio y el servicio ocupa el repositorio si te fijas aquí está tu repositorio va el
repositorio como yo te decía con de las clases de configuración él sabe que todo lo que extienda
de jpa repositor y va a ocupar un un con nexon string que va a estar muy seguramente dado de
alta en un archivo application properties ocupa que le digas de qué modelo quieres entonces ahí
está la otra palabra clave modelo si ocupa un modelo aquí si te fijas los subrayas si yo me voy
igual a su definición le doy clic derecho y a la implementación la enlazo aquí para que me diga
qué clase es si te fijas ahora subió a modelo va entonces ahí la cadenita el controlador ocupa
el servicio el servicio al repositorio el repositorio al modelo va y si te fijas ya se están ocupando
todas las claves todas las carpetas es como separarlo en capas por así decirlo no y tú y
tu modelo es es una clase que basado en estas anotaciones la clase la anotación entity la
anotación table se mapea con la tabla que nosotros creamos acá bueno quien los en los
ddl no en los definition language por ejemplo el de producto vamos a volver a abrir el definición
de no el manipulation sino el definición de producto el que define la tabla producto y si
te fijas aquí está no mi nombre mi nombre de tabla es products igual que la que estoy creando acá
no products sale y las propiedades que tiene son id name y price entonces son esas tres propiedades
las que tengo que agregar no hay di nombre y price el id adelante
a claro
cambiar entre esquemas
ok bueno a ver bueno una una primer nota que habría que hacer ahí de hecho este
es el tema de que cuando tú estás trabajando aquí en microservicios si te fijas yo no voy a no es
que no se haga pero es tal vez un poco ya no tan necesario el hacer relaciones uno a muchos muchos
a muchos porque si te fijas ahorita vas a ver cómo se relaciona el producto con órdenes con los varios
y yo no yo no voy a crear ese tipo de relaciones porque porque las bases de datos están contenidas
en servidores separados aunque es como que la propuesta que trae el microservicio cada
bucada base de datos se va a guardar en su en un servidor propio no obstante no quiere
decir que no haya dentro de ese servicio relaciones entre tablas que si se pueden mapear cuando quieres
trabajar de entre esquemas lo mejor que puedes hacer es definirlo aquí en la conexión este no
sea tú aquí puedes mapear qué base de datos también puedes decirle hacia qué esquema se
va a conectar y de esa forma este ya tu conexión debería de funcionar no necesitas especificarle
más además si no lo quieres mapear en el conexión este si hay si hay ciertas anotaciones que te
permiten mapear los esquemas va aquí como el ejemplo que yo traía era muy este es muy
burdo realmente es muy de tablas sencillas para no invertir mucho tiempo pues no se ilustra no es
necesario crear varios esquemas pero incluso me parece que aquí mismo tú puedes dar de alta
el esquema con esta anotación no con el nombre punto el nombre de la tabla y con eso la estarías
mapeando de hecho creo que ésta también tiene que funcionar lo podrías probar ahorita que toque la
práctica meterse el esquema public que es donde tenemos aquí nosotros dado de alta la tabla si
y este te fijas aquí va a estar public este en la base de datos tu esquema y este aquí está el
esquema y lo puedes este mapear y te debe de funcionar según yo si te debe de funcionar con
esta misma anotación que te estoy poniendo entonces lo puedes mapear de esa forma o lo
puedes mapear simplemente así en caso de que sea el mismo esquema va y más o menos
perfecto va que va ok entonces este bueno esta es la clase del modelo de productos va entonces si te
fijas tiene las anotaciones para que está este campo se ha tratado como un identificador o una
primaria aquí tiene su generación su estrategia de generación identidad para que funcione como un
este como un identidad y no valga la redundancia como un serial aquí en en pos en pos que así
así lo lo maneja el bar chart de 255 pues es un string y aquí tenemos como un doble el numérico
lo mapeamos de esta forma sí y tienes también su constructor y tiene sus gators y sus cedars va
aquí está la sección de gators y cedars y este es el modelo este tal cual es el modelo y nos falta
por recorrer una última clase que es el dto el dto es de hecho el primero que se maneja porque
esto que se maneja acá y lo puedes ver los de teos lo puedes ver tanto en los ricos como
a los responses va entonces este es el que les decía que solamente es una clase que sirve como
para para ir pasando las peticiones y las respuestas desde que llega la petición hasta
que se va al modelo o se guarda en la base entonces el controlador también ocupa al
dto si te fijas aquí desde el control te puedes ver el dto y el dto no es más que
es la misma clase modelo este pero sin las anotaciones de persistencia no es él no es
una entity no es un table es un este es una es un dto un data transfero y obje así plano y simple
o tienen las tres propiedades tiene el constructor y tiene sus que ver si se va no sé si haya duda
adelante
ok
ok bueno esta clase modelo como dices las anotaciones nos sirven porque esta clase sirve
para utilizar persistencia es decir esto se va a guardar en la base de datos esto es esto es
un modelo que se mapea con la base de datos y que es necesaria por las por los frameworks de
persistencia y de jpa si cuando hablamos del repositorio te acordas que te decía que extiende
de jpa él requiere un modelo para que sepa cómo guardar la información y esa clase modelo debe
de tener estas anotaciones esa es una para darle un por qué de esta clase digamos esta si no tenemos
duda de que debe de ir ahora el dto para que existe ah bueno sirve para que tú puedas tener un orden
y puedas diferenciar tus request y tu respons en objetos que sean para ti elegibles porque a lo
mejor yo yo puedo prescindir del dto pero puedo crear aquí otra otro objeto x no y guardar
información o puedo incluso pasar los parámetros tal cual no o sea puedo guardar el puedo pedir
que me den el long id el name y el doble no así tal cual las propiedades este aquí en el controlador
puedo pedir que me llegue un request así pero lo más digamos la mejor práctica es manejarlo todo
como objetos entonces el dto sirve para que te llegue el request el objeto request yo lo yo lo
tengo más bien como un dto y ese request o ese dto es el que yo voy propagando hacia las diferentes
capas por ejemplo el controlador que ocupa el servicio aquí si te fijas cuando ocupa el create
este producto que llegó es el que llega del de la petición el parámetro va lo voy mandando y eso es
lo que me lo voy a convertir en una entidad o en un modelo para que se transforme de esta forma y
se pueda guardar entonces esa es básicamente la diferencia una es para que en específico se
guarden la base de datos y el otro es para que se maneje la el request el inter exactamente exactamente
el modelo correcto exacto si no tuvieras base no ocupas el modelo puedes ocupar el
dto y lo puedes este ir mapeando incluso para fein clients este tú puedes propagar los los
dto y en otro micro por ejemplo el de órdenes que ocupa consumir al usuario entonces tú puedes
crear un en órdenes un dto de hecho así está así lo vamos a hacer en órdenes tú creas un
dto de usuarios porque es el que vas a mandar al aquí al microservicio de usuarios y ese dto
es el que se va a convertir en un modelo cuando llegue allá la petición va pero sí básicamente
esa es como esta es toda la arquitectura que se ocupa en el crudo en lo en lo de hecho es
la misma que se ocupa en los tres crudos va este caso vimos productos en la diapositiva viene el
de usuarios y el de órdenes pues es el que vamos a ir haciendo poco a poco va entonces ahorita ya
hay que detenerlo vamos a ir a tomar la hora de comida a las 3 nos volvemos a conectar y ahora
empezaremos con la práctica de crear bueno correr este microservicio de producto para que vean cómo
funciona el crudo lo vamos a levantar vamos a hacer peticiones hacia los cinco en points vamos
a ver cómo responde y una vez que ya tengamos eso ya pasamos a la parte práctica que va a ser que me
ayuden a crear más bien a completar el microservicio de usuarios basándonos en este producto y
completar el microservicio de órdenes igual basándonos en este de producto va realmente es
un ejercicio muy sencillo pero con eso estaríamos terminando el curso el día de hoy va
alguna duda de lo que se plantea hacer
súper muy bien bueno pues entonces nos estamos viendo a las a las 3 es parece esto provecho hasta luego                

on 2023-08-31

language: ES

                  WEBVTT
al irlo descargando y demás, lo vamos a configurar igualito que el de producto.
Y yo les recomiendo que tengan abiertos los dos, el de usuario y el de producto,
para que el objetivo es completar el microservicio de usuario y nos vamos a
basar en el de producto. Una vez que ya esté completo el de usuario,
igual lo podemos correr, lo probamos, hacemos el CRUD, ¿no?
Y una vez que ya esté el de usuario, nos vamos al de órdenes.
Ok, si ya la tengo, entonces aquí le doy Next.
Perfecto. Y el Outlook es con esto, de acá.
Sí, no, creo que, creo que ahí este.
Es que yo antes les dejaba todo instalado, digamos, en la máquina.
En esta ocasión no lo hice así porque quería dar tiempo para esto,
pero ahorita que voy viendo es.
Va a ser más tiempo el que necesitamos para crear las cuentas y luego darles permiso.
Entonces, básicamente así.
A ver, quien pidió el código de verificación es ese.
No sé si se alcance a ver.
De hecho, a todos les tiene que mandar ese.
Ah, perfecto. Va.
Quién más?
Ah, en el uso.
Sí, más bien en tu usuario.
Tu usuario va a ser este.
Mira, aquí en la URL dice capa, la tam, no.
Eso lo pones en user y el password es el que les pase por por chat.
Aquí en GitHub tienes que dar en iniciar sesión.
A ver cómo era.
Es que yo me tendría que desloguear.
Ah, bueno, mejor habrá una de incógnito.
Permítanme tantito.
Acá me.
Así voy.
Cuando tú te metes aquí a GitHub le puedes dar aquí en login y te va a
para te va a llevar esta esta pestañita.
Va y desde ahí pues ya metes el user y el paso.
El usuario se hizo los copio.
A ver.
Es este.
Te mandó a ver.
Ese es el usuario que les pase y el paso también ahí se los se los pase.
A ver, a ver, no voy a no voy a desnoguiar yo también para que lo veamos aquí todos juntos.
Entonces.
Básicamente ahí ya debía haber.
Ella me mata la sesión.
Ok, el código en tu caso es 551.
446.
Perfecto sale.
Entonces este a ver en para los que no hemos podido entrar aquí en GitHub.
Ahí estoy. Va.
Si yo le doy en sign in.
Me va a llevar a esta terminal.
Bueno, está está pantallito.
Va entonces el usuario que voy a poner es el que yo les pase por por chat, que es este.
Que yo lo voy copiando.
Ajá me exerció que no tenga espacios, hay nada y el password igual es el que les pase, que es este.
No estoy mal.
Es este.
Ahí y cuando le doy en firmar, ya me ya me metí a esta página.
Va ok.
Bien, ya dentro en esta página este.
Yo le doy aquí al al monito que se veía hasta la derecha.
Y ahí puedo ver mis repositorios.
Ahí le pico y ya me debe llevar a esta página.
Sale.
Déjenme ver quién más ya está ahí adentro.
Ah, correcto. Para crear el branch voy a hacer el ejercicio.
Aquí me meto en user service.
Me meto user service.
El password lo pase ahí por el chat.
No sé si lo puedes ver.
Es uno que dice Q grande, K de kilo, A minúscula, A mayúscula.
Sí, va sale.
Entonces para crear la rama me meto aquí el repositorio.
Y la sección de branches ahí le pico.
Va y aquí ya me debe de aparecer este botón en verde.
New branch. Yo le pico y entonces yo le voy a poner una inicial,
por ejemplo, digo mis iniciales.
Diego Iván Valencia Velázquez y la rama.
El source debe ser feature first day, es decir, este.
Y cuando ya esté eso, ya le hacen create new branch y listo.
Correcto. Adelante.
Y ya con eso, correcto.
Va. Y una vez que.
E correcto. Aquí me voy a detener para que cuando ya esté en todas las ramas.
Ahora en la terminal vamos a bajar esos cambios,
pero ahorita me espero hasta que me indiquen que ya tienen las ramas.
Entonces me voy a ir cambiando.
Me voy a ir cambiando y voy acá.
Ok.
Se ve.
Me voy a meter yo en el de productos.
Yo me tengo que meter al de usuarios.
Es el fecha.
Ahí está.
Ok, este veo ya todos quedan sus ramas.
Veo una, dos, tres, cuatro, tres, veo seis ramas.
Creo que ya estamos todos, va?
Bien, entonces va.
Entonces el último paso para hacerlo más fácil en la terminal.
Este métanse a donde está la ruta de su carpeta,
de su servicio de usuario y van a ejecutar el comando que les pasé también por chat,
que básicamente es hacer un fetch.
El comando fetch lo que hace es actualiza todos los últimos cambios
que se han hecho al repositorio sin hacer pull.
Entonces aquí pudimos haber hecho un git pull o un fetch.
En este caso, pues lo más recomendado es hacer un fetch.
Sale.
Y una vez que hagan ese fetch les debe aparecer algo similar a lo que a mí me salió.
Y ya con eso ya tienen los últimos nuevos cambios.
Y ahora sí van a poder hacer el git checkout.
Este comando ya lo hemos manejado, entonces nada más lo escribo aquí.
Git checkout y se van a su rama que acaban de hacer.
Por ejemplo, me voy a meter a la rama que dice a de.
Y con eso ya te debe de aparecer el cambio.
Exactamente, justo.
Va perfecto.
Entonces, en el repos de usuario, ahí adentro hacen fetch.
Les va a descargar los últimos cambios y ya van a poder hacer el git
checkout a la rama que acaban de crear.
Ya que hagan eso, ahí les va a mandar este mensaje.
Ya nada más como para corroborar lo último es un git status.
Ahí ya no me deja escribir.
Esta.
Y ahí también les debe aparecer en qué rama está.
Yo en este caso agarré la de A de E, pero bueno, es este.
Independiente va.
Ya que tengan eso ustedes.
Cuando lo abran desde IntelliJ, ya van a ver ahí su rama, ya van a poder trabajar.
La voy a cambiar al micro de usuarios.
Si te fijas, yo ya debo de estar en ABE y como es copia de la de feature
first day, tengo heredó todo eso.
Listo.
A ver este quién eres, perdón.
No, no te preocupes, para eso está el curso.
Eres ángel solito o Jorge Ángel?
Ángel solo.
Listo, va que va a ver entonces.
Estás en user service.
Ajá.
Y si tú le das un git fetch, a ver, dale.
Ok, a ver, dale un git status, debes de estar en main.
Correcto.
Ok, a ver, entonces ya dale un git checkout y pon el nombre de tu rama.
Pon git espacio checkout.
Checkout espacio y tu nombre.
Ajá, dale.
Estás y si le vuelves a dar git status te debe de mandar a ese ABE.
Correcto.
Ahí estás.
Bien, entonces ahora si quieres abre ya el proyecto en IntelliJ, el de user service
y ya hasta arriba te debe de parecer que estás en la rama de ABE.
Dale open.
Ah, bueno, sí, user service.
En una nueva.
Reabrir este FID.
Ajá, abre el de usuarios.
Ok.
Dale New Windows.
Ajá.
Y ahí estás en tu rama.
Entonces lo que hay que hacer es completar este crew conforme al que hicimos en el de
producto, va?
Bien, entonces mira.
Sale.
¿Nixt alguien más?
O ya creo que creo que ya serán todos ahí este dándole a.
Perfecto.
Bien, entonces.
Sale y vale.
Ahora voy a cambiar de rama.
Git checkout.
Feature.
First day.
First.
Day.
Sale.
Y status.
Y ahí está.
Correcto.
Sale y vale, entonces me cambié.
Perfecto.
Todo esto.
Finish.
Windows.
Ok.
El dog de bolero.
Si está en blanco todo este no, no ha sido escrito.
Correcto.
Entonces voy a voy a mutear mi micro porque no sé, pero está lloviendo y ese ruido.
Este pero aquí voy a estar monitoreando cualquier cosa.
Este me avisa.
Sí.
Yo te recomiendo que si le digas este si agregar a de.
Sí, sí.
Sí, sí, adelante. Bueno, bueno, también lo dejaron de oír o fui yo solamente.
Escuchas a si creo que fue.
Y si nos pudieras repetir porque se te cortó, ándale, te escuchamos, te escuchamos.
A ver, vamos a ver.
Eres Francisco, no?
A ver, a ver este.
En el modelo, a ver, hay que crear la de user, la del new.
Java class.
Y es user.
Acuérdate que es singular, no es user.
Exacto.
A la lenta.
Dice.
Dice, no se puede crear la clase.
Que dice?
Serviz.
User service.
Mode.
Es la directorie.
Sí creaste el modelo como paquete.
Bueno, los folders.
Ya parecían? No me acuerdo.
Ok, ok, listo.
Ok, a ver.
Vamos que raro.
Sí, de proyecto y ya no.
Sí, probablemente si lo volvamos a abrir este.
Se le pasan.
A ver.
Clic derecho, nueva, Java class.
User.
No puede ser, a ver, say users.
No le plug, repositorios.
User service source main.
Java com att, user service model is not a directory.
Qué raro.
A ver, y si eliminamos la carpeta model y la volvemos a crear
porque algo algo ahí hay algo raro.
E reload from disk es como la de refrescar casi está bajo.
Listo, ok.
A ver, va porfa.
Tendría que ser a nivel de com att user service.
Ahí te paras y ahí le vas dando crear el nuevo paquete y vas creando los paquetes.
Acá es.
Y ya puedes poner los models, todo eso.
Entonces no, grésate.
Sale.
Listo, tienen alguna inquietud también, se atoron algo.
Todo bien.
A ver, voy a ir monitoreando.
Y sí, se ve que.
Se ve que van.
Todo súper.
A ver.
Te ayudo con algo y yo van y no van a.
Creo que no está.
Si me escucho yo más bien soy el que no.
Sí.
Perfecto.
Ah, bien, pues bien, entonces a lo mejor.
Fue a donde el rey va solo o algo así.
Sale.
Ah, listo, no, no, no quieres que te ayude con algo donde estás?
No te pures, dale.
Sí, no te preocupes.
A ver, dime en qué te ayudo.
Sí, sí, veo que andas también.
Veo que andas ocupado.
No te pures.
Tres el.
Sí, sí, digamos, básate en el ándale, básate en el proyecto de producto y con eso
completas el de usuario y el de órdenes.
Con eso.
Sale bien.
Va bien.
Este listo parece que todo bien, todo bien.
Todos.
Entonces me voy a volver a mutear.
Aquí voy a andar.
Ahí te están dando broncas, Armando.
Ok, ahora vamos a ver qué error marca.
A ver.
Ese lo copiaste tal cual del de productos.
Ah, como que.
A ver, a ver.
Echale.
El láte.
Me va levantando.
Ahí va.
Iniciando el hikari.
A ver, a ver, mando un error.
A ver, se puede subirle.
Vamos viendo que se trata.
Dice la base de datos, Prodok.
Nos está conectando a Prodok.
Ya viste en el 54, 32 es correcto, correcto.
Sí, si justo.
El puerto es el de usuario, pero la base de hasta el producto.
Ok, con eso, con eso debería de jalar.
Bien, entonces sale.
A ver, vamos a ver a Jorge Ángel.
Tenés ahí broncas.
Así que a ver este así.
Pero esta este de user lo trajiste de del de
de fit to first.
Porque.
No, es que es a ver, déjame revisar, porque entonces ahí van a tener todos.
Déjame checar rápido.
Espera un tantito.
Sí, porque esas esas dependencias no deben de estar.
Por eso eso te va a dar problema.
A ver, entonces déjame ver.
Sí, sí, trato de dejarlo igualito a las dependencias del de producto, porfa.
Mientras yo voy a revisar si en la rama de fit to first de.
Porque según yo también las quité, vamos a ver en el POM.
No deben existir si quien no debe existir nada de eso.
A ver, vamos a ver.
Hay que crees que sí, si ahí más bien yo me equivoqué.
Sí, sí, qué bueno que me dices, voy a hacer ese cambio.
Pero bueno, para todos este.
Ahí hay un error en el POM de usuarios.
Ese POM también se pueden ayudarme a revisarlo y tiene que estar igual
que el de este el de productos.
Va para que no batallemos.
Ah, de hecho, de hecho no hubo error, más bien era que también tenían que revisar el POM.
Cierto? Sí, sí, más bien la práctica también tiene que revisar el POM.
Entonces hay que hay que emparejarlo al de productos.
Va bien, sí, perfecto.
Bien, bien, muy bien.
Sale entonces.
Ok, que digo, al final nada más es quitar dependencias, eliminar algunas perfectas.
El de órdenes también este.
Pero tú tienes todo el día, si no tienes tiempo de hacerlo ya hoy este.
Ya mañana vamos a empezar con esto ya levantado.
O sea, nada más es como para que ahorita entendieran cómo funciona el microservicio
o demás, qué es lo que hace prácticamente es un cruz cada uno de los productos.
Va, pero sí, sí, ya no da tiempo, que de hecho es el caso.
No, no hay mayor tema.
Mañana arrancamos ya con todo esto ya terminado.
Perfecto. Bien, entonces.
Vamos a ver.
Quién más creo que Iván ya está acabó.
Vamos a ver Iván.
Este ahí estás haciendo el put ya te quedó, no?
Ya tienes el creó. Andale, fíjate.
Ahí está. Perfecto.
Ahí está. Bien, entonces.
Sí, bien, pero ya ya lo tienes.
Super. Sí, porfano hasta el puz y ya que queda en tu rama.
Bien, entonces va a acabar.
Sale, entonces ahí ya quedó.
Vamos con Francisco David.
Vamos a ver cómo va a ver.
Tienes alguna duda o algo, algo en que te hayas atorado?
Hay londas ahí construyendo.
Ok, está bien. Perfecto.
Sale y vale. Muy bien.
Ahí todavía estás en construcción.
A ver, vamos a ver.
Que dice variable y user repositorio.
Podrían haber sido inicializada.
User repositorio.
A ver, veo que ya la tienes.
User repositorio.
El paque. No, no, no.
A ver, dice.
Ah, ok, mira.
Fíjate que ahorita estás en una clase que se llama user series input
y estás usando un constructor que se llama user repositorio.
Entonces el constructor este.
Correcto.
Va, va, va.
Échale. Bien, entonces. Va.
Ahí hay algunos cambios que hay que hacer.
Bien, entonces. Va, sin problema.
Exacto. Bien, entonces.
Échale.
Sale. Entonces hice este.
De más.
A los cuatro.
En points. Perfecto.
Sí, son cinco.
Sí, hazle un pul y ya estuvo.
Ya estuvo perfecto.
Ya eso se sube a tu rama.
Pero bueno, todos los días terminó el día este.
Mañana, como les decía,
mañana ahora a estos tres microservicios que estuvimos haciendo hoy,
estuvimos repasando, les vamos a añadir
la funcionalidad que nos proveen las librerías de Spring Cloud.
Como el monitoreo, la tolerancia a fallos,
la distribución, la configuración distribuida,
el descubrimiento de los servicios, todo esto que nos trae la propuesta de Spring Cloud.
Se los vamos a ir añadiendo la próxima clase que es mañana.
Van a ver que nada más se.
Bueno, la tarea ya es más bien configurar servicios por medio de estas librerías.
Entonces, por eso es muy importante que ahorita identifiquen dónde está el POM,
el properties, porque mañana vamos a estar trabajando meramente sobre esos archivos en cada micro.
Vamos a estar añadiendo dependencias nuevas, vamos a estar metiendo propiedades.
Y pues bueno, eso es lo que vamos a estar haciendo mañana.
Eh, por hoy pues ya termina el día y pues bueno, no me queda más que agradecer.
Y mañana nos vemos igual nueve de la mañana.
Les parece bien.
Entonces, pues muchas gracias.
Hasta luego.
Los que los que tengan su código por fagan pul y listo.
Con eso ya los se crean su rama guardado.
Sí, simplemente este hazle un.
Eh.
Ah, bueno, a ver, les voy pasando los comandos para el porno.
No, pero se los voy pasando.
Ponle un ID ad de punto para que agregue todos tus cambios.
Luego escribes que comit menos M.
Ah, bueno, todo esto yo luego desde la terminal.
Creo que es más fácil.
Le ponen mis cambios.
No sé, un mensaje a su comit.
Y ya ahora sí hacen el pus.
Y con eso ya queda en su en su rama los cambios.
Sale.
Y listo.
Ahora sí, con eso terminamos y nos vemos mañana entonces.
Dale.
Hasta mañana.
Hasta luego.
Dale.
Sin problema.
Hasta mañana.
Nos estamos viendo.
Hasta luego.
Quieren que les ayude con algo, amigos?
Ángel, Iván.
OK.
A ver, me conecto tu compu.
Espérame tantito.
Vamos a ver.
Ángel.
Listo.
Ya te veo.
¿Qué necesitas?
A ver, dice, estamos en la clase UserService.
OK.
La implementación.
La clase debe ser clasos tracta o implementar un método GetAllUsers.
OK.
A ver, entonces tienes el constructor.
Implementa.
Public interface UserService.
A ver, me dejas ver la de producto.
¿Cómo está la interfaz?
Vamos a la de producto.
OK.
Entonces, a ver, hay que abrir ahí la interfaz, porfa.
El Product Service.
Ándale.
Ahí mero.
Dice Public interface ProductService.
Y tiene sus métodos.
OK.
Sale.
A ver, entonces tenés que tener primero un UserService.
¿Va?
Es UserService.
Lo tienes.
Ahí.
Perfecto.
Public interface.
Y ya tienes todos sus métodos.
OK.
Hasta ahí vas bien.
OK.
Y luego nos vamos a la implementación.
Que es ahí donde está marcando el problema.
Dice Public class.
Override.
Ah, OK.
OK.
Es que fíjate que creo que no existe ese método GetAllServices.
¿O sí?
Ajá.
Correcto.
Es que ese no lo encuentra.
Y más bien es GetAllUser.
Es correcto.
Exacto.
Dale, guardar.
Y vamos viendo cuál otro no existe.
Ese de UserProduct creo que tampoco existe.
Ese de UserProduct también hay que cambiarlo.
Correcto.
Exacto.
Fíjate que ya tienes todos los métodos.
Ahora hay que cambiar sus.
El continúo, por ejemplo.
Ese objeto en la línea 45 no puede ser un Product.
Tiene que ser un User.
Correcto.
Exacto.
Perfecto.
Exacto.
Sí, ya que ejecutes, si te fijas,
ahí tú ya estás en la rama.
Ah, bueno, en tu repositorio.
Ahí estás ya en la rama.
Ahora hay que irnos al repo de UserService.
Entonces, ahí en tu Git Bash, si quieres puedes darle un CD.
UserService.
Git ADB, punto.
Va separado.
Ahí está.
Git ADD, punto.
Luego dar un commit, git commit, guion, m.
Espacio.
Y entre comillas ponle un mensaje.
Por ejemplo, no sé, crud o cambios, no sé.
En User, perfecto.
Y ahí está.
Ahora ya el Input.
Git push, correcto.
Con eso ya estarían tus cambios en tu rama.
Perfecto.
Ahí si te pide firmarte, te firmas con las credenciales
que les pasé.
O lo puedes poner ahí y utilizas las que te pase.
Adelante.
Bien, todos, nos vemos mañana.
Perdón, ¿quién me habló?
Es Jorge Ángel.
Iván.
Iván.
OK, Iván.
¿Qué me pediste que hiciera?
A la rama.
Ajá.
OK.
A ver, entonces, tus cambios.
Fíjate, a ver, si estoy compartiendo pantalla.
Vamos a ver.
Sí.
Así se ve.
Bien.
Entonces, fíjate, para ver tus cambios,
yo me voy aquí a los repositorios.
Sí, actualizo y me voy al de Usuario.
Ahí dice que ha habido mucho movimiento.
Entonces, me voy aquí a las ramas.
¿Y cuáles son tus iniciales?
Perdón.
Y aquí está.
Y RPR.
Sí, dice que hace seis minutos.
Vamos a ver tus cambios.
Este.
No, así no se ven los cambios.
Déjame tocar.
OK.
Aquí está tu usuario.
Aquí están las ramas.
Y veo los commits.
Ajá.
OK.
Entonces, a ver, si yo me voy.
A comparar aquí feature first day contra la de RPR,
que es la tuya.
¿Y de dónde bajaste?
Ajá.
Aquí están tus cambios.
¿Qué sí?
Básicamente son los que hicimos del crochet.
Está bien.
Está perfecto.
Sí.
Sí, aquí está.
Sí, men.
Ya estuvo.
Con eso ya está.
Vale.
Nada a ti.
Ahora le nada a ti.
Mañana los escuchamos.
Ahora le.
Bye.
Listo.
¿Necesitas algo más, Ángel?
Ajá, perfecto.
Que descanses.
Hasta luego.                

on 2023-08-31

language: NN

                  WEBVTT
සිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිසිස                

on 2023-08-31

language: ES

                  WEBVTT
ah, listo, sí, tienes, ya, ya puedo verte
Buenos días
ah, bien, entonces, va, me parece bien
bien, entonces
de todos modos de esto te acoso un andele, nada de cierto
nooo
no, no te preocupes
Buenos días
ah, entonces, vienen tarde
está bien, anoche se desconectaron bien tarde igual
es que es viernes, Andi
ah, jajaja, ya es viernes, Marseille, es septiembre
ah, llueve, nada de cierto
no, porque me da miedo, porque ya no voy a poder bajar
porque, porque estoy en el quinto piso
no, manche, ah, yo tengo miedo
entonces ya, ahí, tendré croquetas a la mano
jajaja
ya estamos la mayoría, entonces vamos a empezar
vamos a empezar contigo, Diego
buen día
va
este, buenos días
bueno, yo ayer estuve
bueno, continué con la tarea esta de agregar un token a
a, de los servicios de operadores
de wallet
para, este, que vayan a mi opso y
y obtengan la información
con el token
entonces, eh
un segundo, eh, dame un segundo, estoy, este, revisando una parte, dame un segundo
listo, ¿me repitas la pregunta, porfa?
jajaja
ajá
ok, a ver
¿quién me habló, perdón?
para Giovanni
a, vamos a ver dónde está tu máquina
no sé por qué no                

on 2023-08-31

language: ES

                  WEBVTT
Entonces, ahí te descargas este order service y estás todavía en la rama feature first
day.
Lo que hay que hacer es irse al repositorio, por favor.
Ahí hay que loguearse.
Ándale.
Sí, sí, ándale.
El usuario lo encuentras en el chat, también lo mandé.
A ver si quieres abrir el chat.
Correcto.
Sí, según yo sí.
No te lo detecto.
Híjole, qué mala suerte.
Según yo sí, dale copiar.
Y no, no, no te parece.
No, a mí sí, que crees que a mí sí.
Híjole, qué mala onda.
Porque será.
Les voy a enseñar un truco.
Mira.
A ver.
Creo que sí, sí, de hecho sí, está ahí el botón.
Tal vez en properties.
No.
¿En dónde la viste, perdón?
A ver, sí, para que nos instruyas en esa puerta.
Office.
Permitir.
A ver, inténtenlo.
Eso no la sabía, pero es bastante buena.
Sí.
Sigamos el navegador que tiene alojada la máquina virtual.
¿No?
Perfecto.
A ver, inténtenlo.
Yo estoy usando Edge y no hice alguna configuración.
No recuerdo haberla hecho, entonces.
No sé también cómo que tiene que ver, yo creo, con cada
navegador.
No es cierto, no estoy usando Edge, estoy usando Chrome.
Pero, a ver, no recuerdo.
Pero sí, fíjate que sí veo la opción que dices.
A ver, no lo pueden intentar los demás.
Igual y con eso queda.
Ya no se complican tanto la existencia por el copiar.
¿Y te dejó?
Sí.
Y ahí lo pones.
Ya se lo pasaste.
Ah, bien.
Entonces, también esas sirven, mira.
Ahí está.
Sí.
Bien, entonces.
A mí me sale ese mensaje siempre que hago copiar, pegar.
El grisecito que la notificación es ahí.
Copiado el portapoples.
Listo.
Va.
Bien, entonces.
Va, entonces, ¿qué micro te toca agarrar?
¿Cuál vas?
OK.
El de, bueno, falta el de usuario y producto.
Digo, usuario y órdenes.
El de producto ya está.
Entonces, ¿quieres agarrar el de orden?
OK.
Pícale el de orden.
OK.
Entonces, ahí hay que crear, hay que ponerle en branches.
Hay que crear una nueva rama.
Ajá.
Ahí dale new branch.
Correcto.
Ahí pon tus iniciales, por favor.
Y luego en donde dice source, elige la rama feature
first day.
Ahí está.
Las create new branch.
Correcto.
Ahí está.
Y entonces ahora te vas a tu máquina, por así decirlo,
donde tienes los repositorios, a tu directorio donde tienes los
repos.
Ajá.
Le seguí.
Puedes darle este CD y entre comillas simples,
te pegas la ruta del directorio.
Se tarda un poquito.
Ahí está en el disco C.
OK.
En usuarios.
En nobleproj.
Correcto.
Repositorios.
Perfecto.
Ahí, cópiala.
Y ahí es que se ve entre comillas simples.
Correcto.
Exacto.
Paste.
Excelente.
Ahí le vamos a quitar el último carácter.
Desde donde dice ese.
Exactamente.
Correcto.
Sale.
Y ahí ahora hay que darle un comando.
Y bueno, hay que entrar al repositorio que copiaste,
que es el de órdenes.
Hay que meterlos al repo.
CD.
Order.
Order service.
Ajá.
Ya, ahora sí desde ahí ya puedes darle un git fetch,
por ejemplo, para que te traiga tu rama.
Ajá.
Ahí está.
Ahora ya nada más usa un checkout hacia la rama que es
la tuya.
Ah, pero que va el git checkout.
Ahí te falta el git.
Correcto.
Ahí está.
Ya cuando lo abras en el IntelliJ,
o sea, yo nada más cambié a IntelliJ y en automático te va
a cambiar la rama.
Ahí ya te la cambié solito.
Ajá.
Ajá.
Y ya a partir de ahí ya puedes empezar a desarrollar.
Hay que basarse en el de productos.
No, el de productos ya está hecho.
Es el que hicimos en la clase.
Entonces, el de productos es para que te bases en ese y
completes este de órdenes y el de usuarios.
Ajá.
El de productos tiene que estar apuntando igual a la rama
feature first day.
SS así normalito.
Va.
Sale.
Entonces ya los puedes ir completando.
Este, yo creo que ya no te va a dar tiempo a ti,
pero el repo queda activo.
Creo que todavía les dan un día más o dos.
Sí, sí te aconsejo, si quieres, pues ya,
lo puedes hacer fuera de curso para que lo revises.
Según yo no está tan complicado.
Sale y vale.
Bien, entonces todavía faltan 7 minutos.
Entonces vamos a esperar para ver este,
qué tanto avanzamos.
Va.
A ver, vamos a ver.
Tú eres ángel.
¿Dónde estás?
Híjole, que crees que tampoco veo tu compu.                

on 2023-08-31

language: ES

                  WEBVTT
que es que se revisa el pom y
sal
de solo alarma, pasara dos minutitos mas
40
me le bajo porque es una mano fuerte
ok
mientras pues ponemos la norma de este modo
listo va entonces este como les
fue si lograron levantarlo
quien siente así que ya casi la tenía
yo creo que varios no
ok a ver entonces este voy a compartir
y vamos dándoles solución al
el ejercicio va
a ver me avisen cuando ven mi pantalla
ya se ve perfecto
ok bueno entonces este
vamos a continuar con la parte de lo que
está en el clou
el objetivo de hacer la práctica de ese
ratito y no dejarla en conclución yo yo
vi que varios ya terminaron al menos un
micro y lo levantaron hicieron el crud
entonces eso está bastante bien
este la idea es que pues logran
identificar en el micro en los tres
micros como como como están las capas
no que se que se este que se que se
desarrollarán que se propusieron para
que se podamos ver que las capas están
como ya lo vieron en los tres micros
servicios en el de producto en el
usuario y en el de órdenes entonces la
idea de eso es para que eso sea lo que
menos complicación nos de porque
realmente
lo lo la parte de añadir es pinclao o
esas librerías solamente es pura
configuración ahorita que veamos vamos
a ir viendo ahora cada producto de los
y vamos a ir viendo que simple y
sencillamente es añadir dependencias en
los poms configurar y listo
realmente yo creo que se van a añadir
dos o tres líneas en cada micro en
cuestión de programación no no es este
ya no es el objetivo es más bien
configurar y bueno esa es la idea no que
vamos ahorita a ir revisando
del ejercicio pues bueno creo que este
al ver que al menos un micro lograron
levantarlo eso me da a mi entender que
este que si dominaron la la estructura
lo único que sucede es que bueno yo
comparto la misma opinión que ahorita
de tener ustedes que el tiempo fue muy
cortito no y está bien la verdad es que
si está un poco holgado las 14 horas
para ver todo el temario pero este pero
bueno digo más bien está muy justo no
el tiempo pero pero bueno al menos
se logró hacer una una práctica
levantaron un micro y pues bueno con eso
este es más que suficiente va ahorita la
forma de trabajar es este les voy a
pasar ahorita las bueno yo les voy a
mostrar mejor dicho como está funcional
ya toda la arquitectura nuestra
arquitectura de microservicios que si se
logra ver ahí son como siete proyectos
que se abren en paralelo que es
básicamente lo que les platicaba ayer
no en ventajas desventajas de las
desventajas al menos yo así lo veo este
para hablar de microservicios pues
entrada tienes que tienes que tener
fierro no tienes que tener unas
máquinas potentes que te aguanten abrir
siete instancias de intel y con
corriendo java corriendo meiven
descargando dependencias entonces este
es costoso la verdad pero bueno ya que
ya hay que acostumbrarse hablando de
microservicios pues que así así se van
a hacer las pruebas así se van a hacer
los desarrollos los flujos lo que tú
antes seguías en un solo en un solo
en una sola clase probablemente no en
varios métodos a lo mejor este en un
en un solo en una sola instancia en un
solo proyecto ahora lo vas a ver así
en varios en paralelo entonces a veces
probar los flujos pues bueno si resulta
algo complejo hablar de la documentación
pues también pero bueno sus ventajas
desventajas también es que le brinda
independencia cada componente a tu
aplicativo lo que decíamos y mañana se
me cae a orden services pues yo puedo
seguir continuando con el alta de
usuarios con la de productos no incluso
mi front end va a seguir respondiendo
se traduce en una mejor experiencia de
usuario etcétera etcétera que digo al
final para eso también de eso también
hablamos no el hecho de darle esa buena
experiencia al usuario de entrar en
nuestros en nuestros aplicativos creo
que eso es lo más lo que con lo que
buscamos todos no como desarrolladores
que el usuario diga a que chida
aplicación no entonces este bueno ahora
vamos a continuar con la presentación
con con lo que teníamos ayer hablamos
en cuestión e ilustramos nosotros de
estos en points estos cinco en points
con el microservicio de productos no
hicimos todo un crud de hecho estos son
cruz no hicimos un crud ustedes hicieron
la práctica de hacer el crud sobre
usuarios que también ya ya quedó y este
algunos todavía incluso avanzaron con el
de órdenes otros ahí vamos como que a
medias pero pero bueno al final el
objetivo era ese no crear crud y creo
que ahí ya estamos todos en el mismo
canal de de para que se ocupa no cada
microservicio entonces este
aquí pues bueno fue es una
explicación de lo que se hace en cada
directorio en cada paquete que conlleva
el con la clase de controllers el modelo
los de teos repositorios el service todo
esto ya lo vimos incluso hasta le metieron
ahí codificación no entonces quedó más
que claro la estructura pues así se fue
armando en este caso se ilustra el
microservicio de user service y bueno así
fue la estructura
este y listo entonces aquí bueno es lo
mismo básicamente te va diciendo qué
clase ir creando en cada en cada este
paquete como cómo se van a ir llamando
y demás no pero todo esto pues ya lo lo
tenemos e incluso están las ramas del
repositorio pues para futuras este
referencias y con esto estaríamos
cerrando el día 1 que fue lo que
lo que platicamos ayer levantar tres
microservicios para hacer cruz que son
las relaciones de usuario producto y
órdenes ahora vamos a ver digamos ya la
parte de en materia es print cloud la
iniciativa que nos que nos trae este
framework y cómo lo vamos a ir
aplicando en esos tres micros que creamos
no que son cruz normales y que bueno
todos en alguna vez ya hemos trabajado
entonces a esta le voy a hacer un zoom
así como rápido este es un pequeño
diagrama de arquitectura de la
arquitectura que vamos a crear no de lo
que vamos a estar haciendo entonces ya
más o menos habíamos hablado de un
primer diagrama ayer es donde se veían
las peticiones demás este es un diagrama
un poquito ya más complejo más completo
también en donde bueno se ilustra que
el cliente que puede ser cualquier
sistema externo incluso un front end una
aplicación una app lo que sea un postman
un cliente de postman hace una petición
hacia alguno de nuestros microservicios
y lo primero que va a caer la petición
es en el en el gateway entonces vamos a
estar viendo un producto que trae
spring cloud que se llama gateway va a
estar viendo lo que es ese gateway ese
gateway después va y lo primero que
tiene que hacer es autenticar esa
petición y lo primero que tiene que
autenticar esa petición esa petición
la va a autenticar por medio de un
servidor que nosotros proponemos que se
llama keyclock y creo que es un servidor
que precisamente se encarga de generar
tokens toda esta parte de los jwt es no
es la intención explicar que es un jwt
ni nada así simplemente es especificar
que es una es un mecanismo que te da
seguridad porque te brinda de
autenticación va entonces este
básicamente es si la petición tiene
cierto token que es válido por o es
generado desde keyclock entonces
aplicas esa esa petición es segura de
lo contrario te va a rechazar la
petición y pues no se va no se va a
cumplir va entonces este esta parte del
mecanismo de seguridad se la vamos a
agregar aquí al al gateway para que
prácticamente haciéndolo así todas
nuestras peticiones van a estar este
seguras porque porque todo va a pasar
desde el gateway o sea ya no le voy a
pegar yo directamente al microservicio
de usuario al de producto o al de
órdenes sino que yo ya voy a tener un
gateway que además un get para que nos
ayuda a tener un gateway porque además
hablamos del tema de balanceo de carga
este uno de los este mecanismos que
tienen los get ways es eso no va a
balancear la carga él se va a encargar
de en función de qué tanto tráfico
haya y hacia el microservicio que quieres
este consumir va va a ir creando
generando varias este instancias de ese
de ese micro y las va a estar este
regulando y va a distribuir ese tráfico
va entonces este una de las de las
ventajas que tienen los get way pues es
también eso sale después que clock
vuelve a pasar su respuesta hacia
gateway y como te decía si todo está
bien nos vamos ahora al servicio de
eureka que es un servicio que tiene
descubrimiento de servicios que es lo
que hablamos un poquito ayer
básicamente eureka es un servidor que
es un mecanismo que nos permite
identificar por medio de los names
cuáles son los microservicios que están
en la red de este servidor estos
microservicios que se conectan a este
servidor de eureka se llaman clientes
entonces básicamente el get way se
conecta con eureka server porque
necesita conocer
quién es el microservicio al que
están al que le están haciendo la
petición si acuérdense que la petición
pues llegó desde acá entonces en ese en
el en este sentido el flujo va así flujo
lineal y una vez que eureka server te
dice identifica que en efecto la
petición se trata de uno de los
clientes a los que él tiene suscritos
entonces ya la petición la puede
distribuir ya sea al microservicio de
usuarios al de productos o al de
órdenes va entonces este si llega en
cualquiera de esos vamos a analizar el
flujo de productos es lo mismo en
cualquiera de los tres cada microservicio
de de usuario producto y órdenes tiene
incorporadas librerías que son las que
nos marca aquí el temario no estas
librerías son por ejemplo el fein el
fein frayen las tres la tienen
incorporada ambos bueno todas las los
microservicios tienen ribbon todos
tienen his tricks y todos tienen
slew
para qué sirven el fein client como
ayer también hablábamos es para que se
comuniquen entre ellos va se van a
poder hacer peticiones por medio de fein
y se van a conocer van a van a poder
acceder a ciertas funciones como por
ejemplo obtener datos de
desde un microservicio hacia otro
ribbon va muy de la mano con la parte de
eureka permitiéndonos hacer balanceo de
carga
his tricks que les decía his tricks está
un poquito desactualizado más bien es
otra librería
que básicamente implementa el mismo
patrón el mismo concepto que es el de
los circuit breakers y básicamente esto
es para que cuando una se intente hacer
una llamada fein client desde un
servicio hacia otro este
proporcioné un mecanismo de tolerancia
fallos quiere decir que si en algún
momento alguien falla en esa
comunicación his tricks nos va a
recuperar esa petición fallida va y por
último viene la librería de es leo
es leo se va básicamente lo que provee
esta librería son unos identificadores
unos numéritos
este una cadena de varios dígitos creo
que incluso también ahí son alfanuméricos
y bueno esos números que son
identificadores únicos se sirven se
guardan no sé se inyectan en cada traza
de las peticiones y esto sirve para que
cuando tú detectes o bueno más bien la
aplicación caiga en un estado de error
algún que haya habido algún problema
por algo con por medio de ese
identificador tú lo puedes buscar en un
servicio que se llama si quien
y vas a poder hacer el rastreo de
errores va es básicamente lo mismo que
hacíamos manualmente de buscar en los
logs no aquí no le tocó pedir a la gente
de infra los logs de los servidores como
para estar ahí revisando bueno es eso
pero un poquito ya más este más simple
no por mí es una interfaz de usuarios
si quien ahorita la vamos a ver y a
través de si quien nosotros vamos a
pasarle esa traza le vamos a pegar ese
número y vamos a encontrar ahí todo el
detalle del problema que se que se
origino va entonces este es un mecanismo
para búsqueda de errores monitoreo va y
después de que la petición llega al
microservicio bueno ahora hacemos la
pausa ya pasaron los 45 minutos bueno
después de que el microservicio termina
de hacer esto lo lleva al bueno más bien
aquí el componente de spring cloud bus
que en este ejemplo tenemos nosotros como
Kafka este siempre está este siempre
está activo va entonces Kafka siempre le
está proviendo de sus configuraciones en
tiempo real a través de lo que se
conecta aquí en el config server y
nuestro config server que se conecta
nuestro config rep que básicamente era
lo que veíamos ayer en un ejemplo este
nosotros en el config repo tenemos
archivos de configuración si que el config
server los va a estar bajando el config
server igual es un servicio es un este
es un microservicio que sirve como
servidor y entonces en este caso
usuario productos y órdenes son clientes
conectados desde config server y el
intermediario entre ellos es Kafka no
que funge como un bus entonces cada vez
que tú hagas un cambio aquí en github este
la los cambios se van a ir propagando
en esos archivos de configuración hacia
los microservicios de producto órdenes
y usuarios va tenemos aquí la
ilustración de sipkin también para el
seguimiento de errores y bueno al final
de que todo esto se cumple la petición
regresa al gateway ya con una respuesta
aquí aquí viaja un request que inicia un
request hasta que llega un response no
llega una respuesta que se la propaga
pues a nuestro a nuestro cliente externo
básicamente este es el flujo que que
vamos a estar revisando vamos a estar
armando y vamos a ir creando la
arquitectura vamos a ver de aquí se van
a identificar nuevos microservicios es
decir hay que crear todos proyectos hay
que darlos de alta y otros nada más son
librerías que se agregan en los pom este
o en los este en los aplicación properties
no en los en los ya me en los properties
entonces esa es básicamente la
configuración digamos explicada de forma
rápida no sé si más o menos quedó clara
el cómo llegaría a ser la petición
cuáles son los micros bueno más bien
los productos involucrados en en este
flujo o si tengan alguna duda o
comentario de este este diagrama
o probablemente sobre la marcha no irán
saliendo las las las dudas
perfecto va pues bueno entonces este
diagrama si ya tienen la presentación
que según entiendo ya lo pueden estar
abriendo este en cada ocasión que que
repasemos porque vamos a ir repasando
cada uno de los componentes lo vamos a
ir este revisando va este bueno ahorita
ya sonora el arma del primer pomodoro
hay que tomar cinco minutos entonces
este bueno para hacer más este
los números la matemática más sencilla
a las 10 con 5 10 con 5 nos nos volvemos
a juntar les parece y continuamos con con
el temor
entonces ahorita nos vemos en cinco
minutos bueno siete ocho
esto entonces ahorita nos conectamos 10
cinco por favor
listo a ver entonces voy a compartir
pantalla y me avisen por fácil
adelante
ok a ver para revisar eso vamos a
meternos
déjame que se quite esto negrito
si
en que este micro me lo pediste
creo que los tres ok entonces mira ese
de orden en la base de datos este desde
la base de datos lo vamos a encontrar
como definition este entonces si te
fijas la fecha la mapeamos con un campo
date en la base de datos
y
este y en el proyecto lo vamos a agarrar
como en el de órdenes el modelo lo
agarramos acá fíjate que tan vamos a
hacer tanto el modelo como el de to
entonces el modelo de fecha
lo tienes igual con un campo date va y
también justo en el en el de to lo vas
a encontrar con la misma a no este este
este de aquí no tiene no tiene la fecha
no es cierto perdóname es que este es
el usuario hay que revisar el de orden
el de orden lo tienes acá igual es con
date
va así es como se arrepentió
de preferencia si porque te sirve para
mapear menos y te fijas así es como
están definidas en la base de datos y
así es como lo de lo trabajarías aquí
en el internamento en el producto y con
el proyecto la programación entonces te
sirve más que nada para eso para que tú
lo puedas mapear y trabajar así como lo
dicta digamos la buena práctica de
nomenclatura quien lleva y lo manejo y
de todos modos está mapeando bien con
las tablas de la base de datos
en donde perdón
en el de orden de to a otras anotaciones
así es aunque esto esto se da porque ya
ve el de to es un objeto que llega desde
el riqueza entonces este las propiedades
cuando te hacen la petición desde acá
desde posman para eso para eso las
mapear porque aquí de este lado son
llegan llegan en formato jason entonces
por ejemplo si mandas un post que es
donde mejor se ve este las propiedades y
te fijas llegan así y eso y son jason
son propiedades jason's entonces para eso
se utiliza esa notación para que tú en
la aquí en el en el en el de to las
puedas mapear y no haya ningún ningún
tema viste aquí está el mapeo
si así es todo eso está para que ahí te
va a te guías eso lo encuentras en el de
producto y ese con ese de producto puedes
levantar el de usuario y el de orden
si acaso el único paso adicional que hay
que hacer en el de orden es crear dos de
teos porque necesitas conectarte en este
en algún momento hacia el producto y es
usuario cuando haces el create va
entonces este si acaso es crear estos dos
de teos y estos de teos se basan en los
modelos de los otros micros que ya creamos
va en sus de teos si acaso es la única
diferencia del de orden pero pero bueno
igual si quieres ver el ejercicio ya
completo en las ramas de develop de cada
micro ya ya está ahí en su totalidad va
cualquiera lo puede ver ahí sale
bien entonces
va entonces este vamos a continuar déjame
poner el otro pomodoro ok va entonces
este siguiente punto ahora sí empezamos
con todo lo que es la familia de spin
cloud el primero de los de los este de
la familia que vamos a estar viendo el
primer producto es el config sale esta
librería se llama spring cloud config
entonces que es lo que hace un cloud
config es lo que ya habíamos platicado un
poquito ayer nada embarrada básicamente
esta propuesta es para que nosotros
podamos centralizar las propiedades de
de los repositorios perdón a los
microservicios en un repositorio
en un repositorio lo podemos este
podemos ahí guardar los archivos de
configuración y a través del cloud
config podemos servirle a los que son
clientes que se que se comunican con
este cloud config este podemos
proveerles esos estas configuraciones
esos archivos de configuración y eso lo
vamos a hacer a través de un mecanismo
que se llama un bus y ese bus en este
ejercicio la propuesta que traemos
es Kafka va entonces digamos el flujo es
así nosotros vamos a guardar en un
repositorio archivos de configuración el
cloud config se va a conectar a ese
repositorio si y ese cloud config va a
servir como un servidor todos los
clientes que se conecten a ese servidor
de configuración que en este caso
hablamos de clientes nos referimos a
nuestros servicios de órdenes de
productos y de usuarios se van a
conectar con él con ese configuración y
van a estar van a estar este conectados
por medio de un bus que se llama Kafka
si ese ese bus va a estar escuchando
todos los cambios que hayan en el en
los repositorios y cuando ocurra un
cambio ese bus va a propagar el valor
de esa propiedad que se cambió hacia los
repositorios y todo eso lo va a hacer de
forma dinámica es decir no voy a tener
que apagar ningún servidor no voy a
tener que hacer nada de ese tipo de
maniobras va entonces digamos igual
podemos hacer aquí una pequeña
anotación nada más como para que se
ejemplifique tenemos por un lado
tenemos el repositorio en github que
bueno puede ser cualquier repositorio
en este caso nosotros estamos proponiendo
usar github de ahí nosotros tenemos la
conexión con el config server
de hecho este repositorio se le conoce
también como config rep es un es un
proyecto es un microservicio bueno no
este no es un microservicio es un
proyecto que se va directamente a un
repositorio de github después nosotros
tenemos nuestro config server que está
conectado con ese config con ese config rep
por medio de una propiedad que es este
una url en un archivo de propiedades de
aquí vamos a configurar una propiedad y
con y le vamos a pasar la dirección de
este repositorio eso es lo que les decía
que ya los micros nuevos que vamos a
estar creando ya nada más es
configuraciones va entonces en el archivo
de configuración de este config server
le vamos a especificar la url de este
repositorio github en este repositorio
github vamos a tener varios archivos de
configuración por ejemplo vamos a tener
el user properties haciendo alusión a
que se va a conectar al digo que son las
que son las propiedades del microservicio
de usuarios también vamos a tener el
product properties por ejemplo que igual
haciendo alusión de que son las
propiedades de configuración del
microservicio de productos y lo mismo
para el de órdenes va el config server
entonces funge como un este un servidor
y vamos a tener varios clientes en este
caso el el user el microservicio de
usuarios
sí también vamos a poder ver el
microservicio de productos y como para
que me quepa todo y no voy a agregar el
de órdenes pero pero bueno también se
sobreentienden no que también entraría
como cliente entonces estas estos este
a este microservicio porque este si es
un microservicio que se va a llamar
config server le vamos a agregar una
librería que
justamente es la librería del config
server de spring cloud no le vamos a
agregar esta librería spring cloud
config eso va a hacer que él se
convierta que se convierta en un
servidor y a estos de acá les vamos a
añadir una librería que se llama
spring cloud config client esta es el
estos tienen el client y esta tiene la
librería config server
es lo que digamos los haría diferentes
nosotros configurando eso y diciéndole
por medio de los archivos de
configuración a qué servidor de
configuración se tiene que conectar con
eso se haría esa liga y entonces así es
como estaría funcionando entonces estos
microservicios el de usuario y el de
productos por medio del config server
van a obtener sus archivos de
configuración o propiedades van a
obtener ya sea el usuario van a obtener
el de productos y las van a cargar
cuando el microservicio levante va a
cargar esos valores va y digamos que
estas líneas que se ven acá digamos se
puede apreciar que en este caso es el
que funge como bus va entonces en este
escenario nosotros hablábamos de que es
Kafka, Kafka va a funcir va a funcir
como un bus y va a estar siempre
escuchando todo lo que sucede aquí en
el repositorio va lo vamos a estar
usando como emisor de eventos cuando
escuche que hay un cambio es de aquí
aquí nos referimos con un cambio pues a
un commit no cuando yo haga un commit en
alguno de estos archivos de propiedades
cambiando por ejemplo un valor
imagínate que aquí tú tienes este
una propiedad que se llama no sé
database no el el el connection string
y tiene un valor cierto valor y después
tú haces un commit sobre este valor y
lo cambias a este otro ese bus va a
escuchar y va a detectar que hubo un
cambio en este archivo lo va a propagar
hacia el microservicio de configuraciones
y a su vez lo va a seguir propagando y
se va a ir hasta hasta asignárselo al
microservicio correspondiente va entonces
así es como se hace la propagación de
los archivos de configuración de forma
este dinámica va sin que yo tenga que
apagar alguno de estos microservicios no
sé si más o menos el flujo quedó poquito
más claro y si sí pues pasaríamos a ver
cómo se ve en la práctica
o quieren que lo repasemos con más detalles
ok perfecto pero más o menos en general
la idea quedó un poquito clara si fue
clara la idea de para qué sirve este
con fix server este bus
entonces vamos a verlo en la práctica y
probablemente ahí salgan este que un poquito más claro va entonces este aquí
en la presentación se nos va a ir
explicando cómo configurar el config
server va el config server literal es un
nuevo microservicio este igual como dimos
de alta el microservicio de producto y
si se acuerdan que nos metimos a esta
página de spank inicializer la vuelvo a
abrir como para que la recordemos esta
página aquí es para generar proyectos de
forma online va entonces igual aquí te va
diciendo la presentación cómo vas a ir
este metiendo el nombre de la propia del
proyecto la versión y toda la metadata
que necesitamos que para que el
lenguaje ocupa hacerle empaquetado en la
versión de spring todo como lo hicimos en
el microservicio de productos va así
mismo se va a ir creando el archivo el
microservicio perdón se llama config server
sí y cuando ya terminas de crear no la
estructura inicial del proyecto es esta
va tú vas a tener un proyecto que se
llame de esta forma con fix server y
igual que e igual que los otros
microservicios vas a tener una clase
que se llama config server application
este que es que es la que tiene el método
mío va que es donde va a iniciar
y nosotros podemos crear una carpeta
bueno está también ya te la incluye la
carpeta de resources y dentro vemos una
una chica que se llama aplicación llame
que bueno aquí básicamente te explican
para qué para qué se ocupa cada este
cada clase va cada chivo
y bueno vamos a hacer una pauta aquí
vamos a ver cómo se ve este archivo
config server entonces yo me meto aquí al
a mi máquina y este archivo este
microservicio perdón ya también está
aquí adentro en el repositorio
a la pestaña de repositorios vas a ver
uno que se llama config repo y otro que
se llama config server ahí hay que buscar
no está acá entonces el que nosotros
creamos por así decirlo en el spring
inicializer es este config server va es
el config server entonces este este
config server es el que yo descargo
apunto a la rama de develop yo ahorita lo
apunto a la rama de develop para que ya
se vea toda la configuración pero al
igual que ayer existe la rama feature
first day que es de donde ustedes lo van
a bajar al final al final el de
al finalizar de nosotros en toda la
práctica desde ahí la idea sería que lo
puedan generar no se para replicar
entonces nada más hay que completarlo
basándonos en la rama de develop va
entonces yo ahorita lo voy a bajar en
develop de hecho todos los micros yo ya
los voy a apuntar a develop para poder
hacer las prácticas va poder mostrarlas
entonces el primer proyecto que ya se
creó en el spring inicializer es config
server que que siguiendo aquí el
tutorial te dice cómo crear la metadata
y demás y ya lo puedes abrir entonces
con del y va yo lo pongo incluso los
tengo aquí ordenados desde el principio
al fin si te fijas hay uno antes que es
el config repo pero de ese todavía no
hemos hablado este nada más lo mencioné
así como a un nivel teórico este este
no es un micro simplemente es un proyecto
que guarda archivos de configuración
ahorita lo explicamos pero realmente el
primer microservicio nuevo a crear es
este config server va entonces siguiendo
el tutorial ahí te va explicando cómo
vas a crear el proyecto cómo viene la
metadata sí y por ejemplo esto está
metada nosotros ya la podemos encontrar
en nuestro archivo pump va entonces te
vas a encontrar el artefacto la versión
la versión de spring boot las
dependencias para eso entonces yo abro
cuando yo lo creo desde el inicializer
y me va a generar todo esto va me va a
decir que la versión es de spring la 263
me dice el group es como 80 y el
artefacto es el config server el nombre
es config server la descripción también
se va a guardar la versión de yaba la
versión de spring cloud y bueno aquí ya
viene toda la configuración y
bueno vamos a ir viendo ahorita cómo se
añaden estas dependencias hasta ahorita
es mostrar este archivo pump y la clase
que nos decía acá no en el paquete
principal tienes esta clase que se llama
config server application contiene
nuestro método main ahorita no veamos
más que esta esta anotación que es la
que ya habíamos visto ya hemos trabajado
en los otros tres microservicios no la
de spring boot application que lo que
hace es tratar de tener un poco de
aplicación que lo que hace es tratar
esta clase como una aplicación de
spring va entonces él va a esperar
muchos archivos de configuración que tú
cumplas con con sus prácticas va
entonces una de esas prácticas es que
va a encontrar en una carpeta que se
llama resources va a buscar si existe un
archivo bootstrap yamel una aplicación
yamel o una aplicación properties en este
caso pues yo por simplicidad elegí el
formato yamel y va a entender que existe
una una configuración en este archivo
este archivo application nos va a cargar
cuando yo levanté el proyecto esto es lo
primero que carga cualquier microservicio
es lo primero que carga las propiedades
entonces aquí en estas propiedades este
ahorita las vamos a repasar porque ahorita
en este punto el tutorial simplemente te
dice que existe un archivo yaba el main y
tu resources aplicado va este ahora vamos
a ir viendo que contiene cada cosa
ahora eso fue hablando del microservicio
config server va ahora nosotros aquí en
esta parte te dice que hay que configurar
un repositorio en git ese repositorio en
git o en este caso nos agarramos un
sabor que se llama github vamos a guardar
archivos de configuración de los
microservicios entonces en este repo
vamos a guardar en vamos a conseguir una
estructura similar a la que nos están
proponiendo acá entonces yo si te fijas
este config repo no es un proyecto de yaba
no lo voy a crear con espin y inicia
la hice simplemente es un repositorio
entonces yo me puedo venir directamente
aquí en la interfaz de de github
y dar de alta un nuevo repositorio
llamarlo config repo de hecho así me lo
pide en la práctica y en la rama que yo
elija yo en este caso igual agarre tres
ramas y vamos a hablar de de lo en esta
rama de de lo que yo estoy guardando
archivos de configuración si te fijas
solamente guardo archivos o sea guardé un
yamel que se llama car service un order
service un product service un user service
estos archivos de configuración como
para que se vaya amarrando la idea son
los mismos o deberían de ser en teoría
es como para que lo no mapeen es el
mismo archivo de configuración que tiene
cada micro servicio en su carpeta de
aplicación properties en el resource es
este archivo o sea la idea es que esto no
esté aquí sino que más bien esté en un
repositorio de enguijo y dijo distribuido
para qué pues porque te puedes encontrar
a lo mejor buen mejor organización porque
a lo mejor no quieres que esté aquí
expuesta para en el proyecto la
cadena de conexión a lo mejor hay una
frase muy delicada para un token no sé
algo no ahí ahí depende de cada cada
compañía sus necesidades pero la
alternativa es eso que tú lo puedes
guardar en un repositorio e incluso a un
repositorio tú le puedes meter mecanismos
de seguridad pues ya un poquito más este
avanzados después meter este por ejemplo
por ejemplo autenticación de doble factor
le puedes meter creencia por bueno
commits por gpg por autentic por por este
por o out entonces este esto ya empieza
a ser como que un poquito aislarlo le
brinda más seguridad no a través de
github es que y bueno esa es la idea
básicamente de guardar de crear un
config repo y tener un config server que
yo pueda guardar todo esto acá de forma
distribuida y que además las propiedades
y los valores que yo vaya agregando acá
los pueda cambiar a través de comics no
si yo quiero hacer un cambio sobre
alguna propiedad acá solamente bajo el
proyecto bueno más bajo el repositorio
cambio el valor lo subo con un commit y
en automático se va a propagar a mis
microservicios va entonces eso es eso es
el relajo de todo esto de lo que estamos
revisando va entonces este este
repositorio que se llama config repo se
crea de esa forma se crean aquí los
archivos y ese es el que yo bajo y de
hecho es el que les decía que está hasta
acá como primer este proyecto yo lo puedo
abrir ese repositorio aquí en en intel y
porque no es más que un una carpeta que
guarda archivos no no es un yaba no es
nada no va esto no va a correr no va a
compilar simplemente va a guardar estos
archivos va entonces este yo estoy
apuntando aquí a de veló que si te fijas
pues tiene los archivos de configuración
de órdenes de producto y de usuarios que
son los que hemos estado este ocupando
va esta es la función del config repo y
bueno eso es lo que nos dicta aquí la la
la diapositiva va crear esta estructura
de de de archivos bueno aquí se ven
incluso un poquito más pro que lo puedes
almacenar incluso en carpetas no como
nuestro ejercicio era muy sencillo pues
bueno directamente ahí el archivo
después ahora sí vamos a hacer que este
config server se comporte como tal como
un config server de un producto de
sprint cloud para eso yo tengo que
agregarle ciertas configuraciones en su
archivo application yaml una de las más
notorias es yo le tengo que decir a
yo le tengo que decir a este config server
de donde tiene que cachar esos archivos
de configuración y para eso nos provee
este esta propiedad que se llama sprint
cloud config server git uri va esta
propiedad en un formato yaml se ve de
esta forma y al meter esta configuración
tú aquí en donde dice uri obviamente
tienes que pasar la url del
del repositorio en donde estás trabajando
cuál repositorio el que creamos en el
paso anterior no donde están los config
el config rep vaya entonces eso se ve
así yo me voy aquí a mi config server
y en el archivo de propiedades que es
este application yaml si te fijas aquí
se ve la propiedad que nos que nos
indica ahí la la presentación no es
que no se trae mi mouse es este va
entonces hay muchas otras propiedades
por ejemplo también guardas un name no
que es el config server este y está
ocupando si te fijas aquí la propiedad
uri y esta uri si te fijas es la que yo
tengo en mi repositorio que acabo de
mostrarles que es en el config rep va es
decir es la misma de acá
la misma url para entrar a mi config rep
si te fijas esto pues me lleva a main
como yo le digo que si cambia entre
ramas bueno hay otra propiedad para que
me cache las los archivos de propiedades
que están en la rama de develop no en la
de main y esa propiedad es esta otra de
acá que se llama default label entonces
yo metiendo esta propiedad default label
diciéndole a qué rama este
pues con eso sabe la configuración que
se tiene que ir a este micro a esta rama
y de ahí va a cachar los archivos de
configuración va esto es este todo lo
que llevamos hasta ahorita va en la
presentación esa configuración
después ya tengo que este
perdón un momento
entonces aquí la configuración
de los microservicios ya vamos a estar
configurando digamos el user service el
product service el order service para que
este se comporten como clientes de este
garchivo de este de este proyecto de
este config server
y para eso pues tenemos que estar
definiendo esta otra configuración que
es el spring cloud config client
para que se vaya a la dirección del
config server que nosotros vamos a
levantar aquí nos dice cuáles son las
propiedades y en qué archivo este vamos
a estar trabajando entonces lo primero
que hay que agregar es esta dependencia
este para que se pueda comportar como un
config client va entonces esto lo puedes
ver tanto en el usuario producto y
órdenes
bueno entonces el son los mismos
microservicios que ya habíamos trabajado
el usuario producto órdenes yo aquí en
este caso voy a agarrar el de productos
que es como con el que yo he estado
trabajando y si te fijas yo como te decía
ya estoy en devel para que yo pueda
mostrar el archivo el ejercicio completo
y aquí adentro pues vas a ir agregando
las deberías que te pide y entonces
en este caso son todas estas de spring
cloud para su configuración no entonces
con esto se va a estar comportando como
un este como un cliente de que se va
a conectar a un config server va entonces
este este archivo de al instalar esa
dependencia de spring cloud ya ya me lo
va a transformar en un cliente y con en
el archivo de propiedades yo le voy a
decir que esas configuraciones las tome
de un microservicio que se va a llamar
config server y que se levanta en el
puerto 88 88 por eso también es
importante que hay que volver a
mencionar eso que cada microservicio
debe tener un name como por ejemplo este
iba a tener un puerto en donde se va a
levantar si te fijas este está levantando
el puerto 88 88 va que es este lo que
lo que
la dirección en donde se va a conectar
va entonces este así es como sería esa
liga ese este config server se levanta en
el 88 88 y por ejemplo el de producto se
está levantando en el puerto vamos a
buscar su puerto en el 80 82 entonces
no tienen problema de levantarse en la
misma máquina es como también un poco
buscar eso no que no choquen los puertos
porque si no pues va a darte problema de
de puertos y listo esa es esa es la
configuración que se agrega entonces ya
este cliente al tener la dependencia de
spring cloud y al meter esta propiedad
ya está ya sabe que se tiene que conectar
a un config server en esta dirección si
yo ahorita hiciera eso y los intentar
a levantar ya por separado ya ya ya
empezaría a tener esos errores que
incluso ustedes ya experimentaron porque
aquí me está pidiendo primeramente
cuando yo levantara el product service
se ya no puedo levantar el product
service de forma individual porque va en
sus archivos de configuración lo
primero que va a hacer es decir ok voy a
buscar todos tus configuraciones aquí en
este en este micro servicio
pero si yo no tengo levantado antes ese
config server pues va a estar mandando
un error de que no puede cachar sus
archivos de configuración entonces aquí
ya empieza a llevar un orden yo ya
necesito tener mi config repo listo para
y mi rama lista un config server ya
configurado para que se conecte esa uri
que esté lista y ya que yo levanté este
config server entonces ya podría yo
levantar el micro servicio de productos
para que pueda cachar sus archivos de
configuración va es así como como
funciona la configuración y es un poco
lo que les decía o sea ya para convertirlos
o para utilizar los los productos de
spring cloud dentro de nuestros micro
servicios ya nada más vamos a estar
agregando dependencias y configuraciones
va entonces este
bueno la otra parte es lo del lo del bus
ya daríamos la práctica pero hasta
ahorita no sé queda alguna duda o queda
un poco ya más claro el flujo de de cómo
cómo se habla bueno aquí nos referimos
con con el config server el config repo
y cada uno de nuestros microservicios
son clientes de ese config server para
que para que se ocupa ese config server
queda queda un poco más claro
perfecto va que va entonces si hay
este preguntas este ahí me avisan va o
si de pronto me estoy yendo muy rápido
igual me me avisan y lo volvemos a
explicar
bien entonces este esa es como la idea
del producto este del config server
y como fijo repo y ahora
bueno ya en la práctica lo que nosotros
necesitaríamos es pues utilizar esos
esas propiedades va ese es el objetivo
de que tenga archivos de configuración
para que esas propiedades yo las pueda
utilizar esas propiedades yo las voy a
utilizar o yo puedo acceder dentro de mi
dentro de mi pero proyecto puedo acceder
a esas este variables a esos archivos de
configuración por medida de una anotación
como arroba value hay otros métodos
hay otros mecanismos pero bueno ya aquí
vamos a exponer este en esta anotación
va
y vamos a ver este ejercicio entonces
aquí creo que en la práctica se ve más
este más claro
entonces nosotros ya hicimos la
configuración de un config repo ya
configuramos también un config server
que se conecta ese config repo y ya
hicimos un cliente que es product service
que se conecta a ese config server va
para traer sus archivos de propiedades
entonces si tú te fijas
vamos al repositorio para que se vea
ahí un poquito más claro en el config
repo yo tengo un archivo que se llama
product service va que es el que le va a
servir al micro servicio de productos
entonces este product service tiene
estas propiedades va
y si te fijas tiene una propiedad que
se llama example property hola desde el
micro servicio de productos va es una
propiedad que se llama así example
property y tiene este valor entonces en
las colecciones de postman que les
pase hay una colección que se llama
config server
con estos endpoints yo puedo obtener
las propiedades de cada micro servicio
que está añadido como un cliente de
este config server ahorita vamos a
repasar estos gets solamente que de
hecho repasando uno son es lo mismo los
otros dos y el post lo vamos a ver para
otra cosa después se las voy a les voy
a decir para qué es
pero entonces ahorita este get de
productos yo con este endpoint puedo
mandarlo a ejecutar si te fijas es en el
88 88 que es donde está corriendo mi
config server
entonces yo le puedo decir dime cuáles
son las propiedades en de mi micro
servicio que se llama product service y
me va a traer todas las propiedades que
tiene alojadas estas propiedades si tú
te fijas son las mismas que están aquí
adentro en mi directamente quien mi
servidor en mi en mi repositorio
y tú estás viendo el server el puerto
el data source y la propiedad example
property que de hecho aquí está va son
las mismas es otra forma de corroborar
que nuestro hay una hay una hay conexión
con nuestro con nuestro config server va
entonces que es lo que vamos a hacer
yo aquí en el product service
puse una funcionalidad para que podamos
traer el valor de una de esas de esas
propiedades
entonces el valor de esas propiedades
lo voy a traer lo tengo aquí descrito en
el controlador si te fijas en el
controlador yo estoy utilizando una
propia una notación se llama roba value
y le estoy diciendo que vaya y traiga el
valor de una propiedad que se llama
example punto property
yo al hacer esto con esta notación y
como la configuración de spring
funciona en automático al hacer esto a
esta variable le va a estar asignando
el valor que encuentre en las propiedades
que se llama example property esto lo va
a leer en su archivo de configuración
entonces tú puedes pensar que esto lo va
a leer de este archivo porque este es su
este también es su archivo de
configuración pero si tú te fijas aquí
no existe esa propiedad incluso yo le
puedo decir aquí example y no la
encuentra porque no está definida aquí
no está definida en este archivo de
configuración local que tiene aquí este
archivo se encuentra más bien en el
repositorio se encuentra en el en el
archivo que está en el repositorio en el
config repo en el archivo product service
aquí está pero aún así la va a leer
porque porque cuando estamos haciendo
toda esta conexión al decirle que vaya
al config server
y de ahí me traiga archivos de propietos
archivos de propiedades ahí es donde
ahí es donde la encuentra y la puede leer
entonces con esta notación a roba valio
yo puedo ocupar y setear el valor aquí
en esta propiedad si y entonces esta
propiedad yo le estoy diciendo que la
imprima cuando estemos haciéndole un
get por id a un producto si te fijas
aquí va a haber un logger y va a
imprimir la propiedad entonces vamos a
hacer ese ejercicio yo ahora para
imprimir lo que está actualmente en el
repositorio si te fijas yo aquí en los
logs le busco la palabra hola o el valor
de la propiedad y no lo encuentra
entonces está está bien para que podamos
hacer la práctica ahí está limpio
incluso le han impido los logs y lo que
voy a hacer es para que se active ese
log tengo que pasar por este método va
que es el de obtención de producto por
id entonces yo me voy aquí al producto
id y si te acuerdas estábamos acá en
nuestras colecciones yo le digo que me
traiga el 3 cualquier este producto
realmente funciona y ahí nos da un 200
si nosotros teniendo esa petición esa
respuesta pues sabemos que lo que lo dio
entonces este
aquí ahora si en los logs yo puedo
volver a buscar la palabra hola
sí y ahí me lo va a encontrar de hecho
si te fijas imprime el valor de la
propiedad no hasta ahí no hay no hay
nada del otro mundo y esto lo está
imprimiendo de lo que está obteniendo
del repositorio porque así lo así lo
configuramos va entonces nos está
trayendo esta propiedad entonces ahora
el objetivo de esta práctica es ver cómo
haciendo un comic y yo cambiando este
valor y volviéndole a pegar a este
micro servicio de producto ahora el
valor va a cambiar de forma dinámica
sin que yo tenga que reiniciar el
micro servicio este es el objetivo del
del bus de el de Kafka en este caso
yo estoy corriendo aquí mi instancia la
misma de ayer y si te fijas bueno ahí
nada más se denunció que se instaló
Kafka y su equipo pero bueno para eso
se ocupa para que funge funja como un
emisor de eventos va entonces cómo yo
configuro esa parte igual en mi config
server yo le tengo que decir que se
habiliten los bus los buses o bueno el
bus yo habilitando esta propiedad en mi
config server este le estoy diciendo
que haya un algo o sea un bus que esté
activo para que esté escuchando cambios
y que el refresco de esas propiedades
también se esté habilitando
y bueno de las propiedades que estoy
esté agregando también son estas no es
todo esto también viene ahí la
presentación ahorita nada más lo muestro
para que sea más este más práctico va
básicamente le estoy diciendo que Kafka
en donde en donde está corriendo que es
en el 9092 esto también lo vamos a
encontrar nosotros en nuestro archivo
que ya habíamos trabajado que es el que
me generó el contenedor si te acuerdas
además de generarlo de postgres yo le
pedí que contuviera también ese
contenedor ecafca no ecafca lo estoy
corriendo en localhost 9092 va entonces
este es por eso que yo aquí apunto al
localhost 9092 y le estoy diciendo que
este actúe como un cloud con como un bus
yo con esto además para terminar la
configuración de nuestro config server
le estoy añadiendo estas dos propiedades
ahí vienen los comentarios para que
para que se ocupan y básicamente aquí
les voy a hacer mención de lo que son
los este los endpoints que se llaman
actuators va entonces hasta ahorita ya
está toda la configuración yo ya estoy
incluso diciéndole que haya un bus en
cafca listo para que cuando haya algún
refresco en este en este repositorio
cafca lo escucha va entonces para para
para esta parte en la en la práctica
digamos en un mundo real cuando yo
hiciera que un commit solito cafca
debería de escuchar y propagar el cambio
pero para hacer eso también se tuvo que
hacer una configuración adicional aquí
en el en el repositorio y tendríamos que
haber conectado la parte de github no
con con ese cafca que tenemos aquí de
forma local eso eso realmente está un
poco ya más complejo de de elaborar en
este para este tiempo que teníamos y
mostrarlo entonces lo que se está haciendo
uso y también esa es la finalidad
mostrar de hecho una de las
características que es que ya viene
incluida con el config server si son los
en points que se llaman actuators
entonces es el refresco que se haría en
automático por medio de un commit que
tú hagas un cambio en la propiedad y que
cafca lo lo interprete y lo propague eso
nosotros lo vamos a hacer más bien a
través de un de un microservicio perdón
de un en point que se llama actuator
este este en point que viene en
en las en se levanta con las
configuraciones del config server si te
fijas aquí en el config server en las
propiedades que ahorita mencionaba yo le
dije que se activaran los actuators con
esto entonces yo al activar estas
propiedades en automático voy a poder
tener un en point que es este que le
pego al 88 88 sigo sigo en el config
server y al hacer esto lo que va a hacer
es es como si yo hiciera que cafca o es
como si yo forzara cafca a escuchar lo
que está en el en el en el repositorio
lo que harían de forma en automático
cuando se ejecute por ejemplo un
pipeline o algo así yo lo voy a forzar
con este microservicio perdón con este
en point entonces un escenario
imagínate que también se cayó el
que hace que se conecte el repositorio
con cafca yo teniendo este en point de
actuator puedo forzar a que aún así
siga funcionando entonces este este en
point es bastante útil entonces ahora
ahora sí lo vemos en la práctica
yo aquí en mi en mi repositorio que se
llama config server perdón config repo
voy a hacer un cambio en mi en mi
propiedad de producto entonces yo le
voy a poner aquí un por ejemplo hola y
adiós voy a agregar esa propiedad o
sea le cambié el valor ya no es hola ahora
es hola y adiós desde el microservicio de
productos yo le voy a dar aquí guardar
pero si te fijas el cambio lo estoy
haciendo directamente en el repositorio
entonces lo que yo tendría que hacer es
me voy a meter a ese a ese repo que de
hecho ya estoy le voy a dar un status
para ver qué marca y aquí te dice que
ya cambió este este archivo lo voy a
agregar esto es simple git voy a hacer un
commit para subir este cambio se hace
cambio en el valor de la propiedad ese es
mi mensaje y al hacer push esto se va va
a llegar al repositorio ahí ya se fue se
fue directamente la rama de devel va
entonces es lo que te decía cuando ya
llega aquí al repositorio a devel este
de hecho fíjate como ahorita ya la
propiedad va a cambiar ahora ya dice hola
y adiós ya llegó el cambio aquí en commit
digo el commit ya llegó aquí al repo
entonces ahí en automático entre si en
el mundo real Kafka ya ya habría hecho
la propagación en este caso nosotros no
traemos esa configuración de de github
con Kafka sino que nosotros más bien lo
vamos a forzar con el actuator
entonces si yo ahorita hiciera la
petición nuevamente sobre productos
primero le voy a decir tráeme las
propiedades que están en el en el repo y
si te fijas este valor tiene que cambiar
entonces el valor ahora para que veamos
que si está actualizado ya la ya la ya
la actualizo o sea el config server ya
está respondiendo bien su conexión va si
yo hiciera otra vez una petición al
microservicio de productos yo todavía
no vería reflejado el cambio porque lo
que te digo ese mecanismo de Kafka con
github no está en este en este ejercicio
incluso yo voy a borrar aquí la consola
yo le doy otra vez buscar
pero me equivoqué de consola
déjame apagar la alarma
yo aquí borraría los logs si y si te
fijas ya no aparece la palabra hola no
pero si yo le hiciera otra vez la
petición aquí al al endpoint para que
pegue al de producto por id
yo este cuando me responda la petición
yo yo todavía voy a seguir obteniendo
la propiedad pasaba es decir si yo le doy
aquí buscar ahí la encuentra
pero todavía no tiene el cambio va es
lo que les decía no está esa esa
configuración entre github y Kafka
pero para para yo imagínate un escenario
en donde incluso en la vida real eso se
cae no ese pipeline no sirve algo pasó
no funcionó y tú de todos modos el cambio
y el cambio de la consola no funcionó
tú de todos modos el cambio ya lo tienes
ahí no podemos dejar que solamente por
eso se no se propague el cambio entonces
para eso está el microservi el endpoint
perdón se llama actuator entonces este
actuator que viene activado en la
configuración del config server si yo lo
ejecuto es un post lo que va a hacer es
que me va a responder con una respuesta
204 que es un exitoso pero no tiene
ningún contenido se no responde nada
si te fijas algo pasó aquí en el config
server aquí te va a mandar un mensaje
que te dice que las llaves fueron
refrescadas eso quiere decir que todas
las propiedades ya las ya fue o sea
nosotros con ese endpoint lo que hacemos
es decirle a Kafka ve y tráete los
cambios que están en el repositorio y
actualizan o sea lo estamos forzando y
con eso
cuando yo haga nuevamente la petición
desde desde el microservicio de
productos
ahí la voy a volver a ejecutar y cuando
esto se complete entonces ahora sí yo
aquí en el microservicio de productos
esperaré ver el nuevo cambio de la
variable ahí si te fijas ya lo encontró
dos veces una en donde tiene la propiedad
que no se había desactualizado y en la
siguiente búsqueda me lo tiene que
traer pero ya con él con el cambio si
te fijas aquí ya tiene la nueva la nueva
el nuevo valor que dice hola y adiós y
ya son los los resultados que encuentra
y si te fijas yo no tuve que apagar el
microservicio va es la propiedad que
viene en el archivo de configuración la
actualizó de forma dinámica va entonces
no sé si con este ejemplo ya es poquito
más claro de cómo funciona todo este
esta familia de producto de config server
config repo el bus Kafka los archivos de
propiedades
o o hay algo
claro que sí a ver entonces cuando yo me
pongo en el repositorio este de todos
los tengo entendido que esta sesión se
está grabando entonces este ahí lo ahí
lo van a tener va de todos los de todos
los comandos cuando tú estás aquí en
el config repo y haces el cambio vas a
hacer un kit status y eso te va a decir
que archivos se modificaron después tú
vas a poner un kit a de de puedes
agregar un archivo uno por uno puedes
hacer todos y a punto y después ya haces
el commit con él con el mensaje va y comí
menos m y das el mensaje que quieres
agregar
mensaje y ya que haces eso el último
comando es un pus va
ese pus
y una vez que haces eso ya se sube al
repositorio
va entonces sí queda clara la
explicación de él de cómo las propiedades
se van cambiando de forma dinámica
perfecto
súper bien entonces va entonces esta es
la propuesta que trae el config server
aquí en la presentación pues básicamente
les va aplicando lo que ya fuimos
haciendo no ahorita este
incluso se cubre esta parte que son las
actualizaciones dinámicas con con lo de
Kafka se habla de los de cómo se
configuran las propiedades en cada
microservicio en sus archivos de
propiedades y hasta ahí terminaría la
práctica
de este primer tema va entonces si
nosotros nos vamos aquí al diagrama
este lo voy a poner
digamos así para para hacerle aquí un
rayón
nosotros ya habría ya entonces con esto
cubrimos la parte de
donde llega la petición no porque
manejamos posma para hacer la petición
y estamos cubriendo la parte de el config
repo va que configuramos un config repo
metimos la parte de spring cloud el
config server perdón y en en en nuestros
microservicios pues está consumiendo ese
ese config server va y bueno obviamente
pues aquí su bus que tiene con con
entonces eso es lo que estaríamos
cubriendo con estos con esta
explicación dentro de este diagrama que
que aquí tenemos va este este primer
este familia de de producto de de spring
cloud
entonces este va si ya queda claro vamos
a tomar los cinco minutos de del pomodoro
y regresaríamos para ver la parte de
creo que tocaría ver este eureka el
descubrimiento con con eureka
entonces este si seguiría orec
entonces vamos a tomar cinco minutos son
igual 11 5 les parece nos nos volvemos
aquí a a juntar y continuamos
listo sale entonces voy a poner el
cronómetro
ahí está sale entonces voy a compartir
otra vez pantalla ahí se ve bien entonces
para que va
ok entonces
bueno si no hay ninguna pregunta
adicional comentario sobre la parte del
config server config repo de los
clientes del bus de cafca todo eso si no
hay quedó claro no no tiene alguna duda
alguna pregunta una inquietud
exacto
correcto
es correcto
listo si hermano este igual te digo lo
único si te fijas la única línea de
programación que le metí en el
controlador pues esto no y esto pues
también es una anotación que nos da
spring este es spring es print este
es print boot para poder manipular las
propiedades los valores de las
propiedades que hay dentro de los
archivos de configuración y esto pues
lo único que dice es traerlo y
imprimirlo ahí en él en él este
en él en él con sema en él en él en
este en este endpoint va entonces ahí se
se pintaría y es lo único va sale ok
entonces este sin como como dijo
armando la idea y creo que si se notó
es básicamente configurar en estos
archivos no aquí y en el pom las
librerías eso tal cual viene explícito
en la presentación va entonces este
bueno esto es lo que lo que trae la
propuesta es print confi y sus clientes
confi repo el bus de Kafka toda esta
parte va los actuators ya ya estuvimos
revisando ahí esos endpoints y demás
sale entonces el siguiente punto a
cubrir es la parte del descubrimiento de
servicio con eureka
entonces aquí nos habla de que vamos a
estar implementando un servicio que si
ame eureka en los microservicios este
este servicio de eureka lo que les decía
es que una de sus ventajas creo que su
ventaja más poderosa es trabajar de la
mano con ribbon si para hacer este
mecanismo de lo que hablamos que es el
mecanismo de balanceo de carga no este
mecanismo de balanceo de carga ahorita
lo hablamos de una forma muy teórica
conceptual en donde nada más este se
explica para qué es no que es y para qué
serviría en un ejemplo real por así
decirlo como tal aquí no se trae no se
propone una práctica porque para hacer
eso pues tendremos que tener a lo mejor
algún ejercicio que haga eso de la
creación de instancias de forma dinámica
hay que ver la forma de crear tráfico
un tráfico significativo como para que
podamos en automático ir creando
instancias para ver cómo se balancea
esas cargas entonces eso solamente queda
platicado a un nivel teórico la parte de
ribbon y el balanceo de carga con eureka
va de ahí en fuera todo lo demás que
provee eureka que es la parte del
descubrimiento si se si se ve y para hacer
nosotros nos referimos a descubrimiento
al hecho de que lo que les decía
nosotros configuramos en todos los
microservicios la propiedad que se llama
que ya ya la hemos identificado en los
properties y con ese name eureka nos va a
ir registrando en su en su red
entonces nosotros vamos a ver una
interfaz es un cliente esto tal cual es
un servidor que se va a instalar ahorita
vamos a ver cómo se instala es un
microservicio se agregan las
dependencias se levanta y eso te expone
una interfaz gráfica en donde todos los
este va a funcionar como un servidor y
todos los que se los servicios que
funcionen como clientes es decir vamos a
instalar la dependencia meyben de
cliente en cada microservicio y que se
conecten igual que el config server
le vamos a dar una url para que le diga
a donde sale el servicio de eureka a
qué puerto a qué dirección y cuando eso
suceda eureka los va a mapear y en
automático por medio de los nombres van
a poder este
se van a poder conocer por así decirlo
en un término más más coloquial van a
poder conocerse
y este y bueno esa es la forma en la
que va a estar trabajando
este este producto que se llama eureka
va entonces ahorita vamos a ir viendo
cómo
cómo se hace esa configuración en cada
uno de los microservicios cómo se crea
este nuevo micro de eureka es un server
los otros son nuestros clientes
ahorita vamos a ir viendo con detalle
esa configuración va entonces aquí mismo
entonces aquí mismo la diapositiva te
dicen igual por medio de spring
inicializer como crear el nuevo micro
que es el de
el de
el de eureka va te va a decir cómo se
puede llamar de artefacto el nombre toda
esta metadata que ya hemos estado
revisando y te va a decir que librería
es la que
la que ocupas en este caso es la
dependencia de netflix eureka server
la que ayer veíamos no que que netflix
propone como que esta arquitectura y
uno de los productos que trae dentro de
sus librerías es este
entonces metiendo nosotros esa librería
en el maven de este micro este ya lo
podemos convertir en un servidor va
así mismo pues vamos a encontrar la
librería eureka client
para los microservicios que se van a
conectar como clientes de ese
servicio entonces bueno eso es lo que
vamos a estar revisando y listo ya cuando
terminas
aquí vamos a ir viendo cómo se se va
haciendo esa configuración en negrito
básicamente se se guarda lo que es este
e lo más importante por así decirlo no
en su archivo de configuración aquí tú
dices que se llama de nombre eureka
tienes la uri en este puerto va a estar
cachando todo lo que tenga de
configuración acá aquí que quiere decir
ya por ver el puerto 88 88 ya lo
trabajamos se está yendo el archivo al
al micro servicio config repo no está
este este micro servicio también se va al
config server perdón y va a buscar
archivos de configuración si hay archivos
de configuración que servirlo los los
los mapea y si no no como es un micro
igual también puede traer sus archivos
de configuración desde ahí de hecho así
lo está trayendo este fíjate que aquí se
sigue conectando igual al config server
el este micro de eureka se levanta en el
80 87 61 y en negrito pongo esta parte
porque sí es importante mencionar que
eureka le tenemos que especificar que él
mismo no se registre como como cliente
de él mismo lo tenemos que especificar
de esta forma para que eureka no se
comporte como un cliente más del mismo
servidor porque si no vamos a estar
teniendo ahí este problemas va bueno
eso es lo que vamos a estar metiendo y
en la configuración de nuestra
aplicación cuando veamos en la clase
main que se crea cuando creamos el
proyecto desde spring inicializer le
tenemos que meter esta anotación que
están disponibles justo por meter las
dependencias de netflix metemos este
enable eureka server y eso va a ser que
nuestra clase spring boot en automático
la tome como un servidor de eureka
va entonces toda esa parte viene a ser
la configuración del servidor entonces
vamos a revisarlo igual yo cree mi
proyecto desde spring inicializer la
página que hemos estado revisando se
crea se guarda en su repositorio
se queda en las ramas y al final aquí
tengo este archivo este este proyecto
por entonces en eureka server yo yo veo
mi pom y voy viendo justo todo lo que
habíamos platicado la metadata de que
que me dice ahí la la presentación de
cómo crearlo es spring inicializer su
descripción la versión de spring boot la
versión de java las dependencias que
voy a estar ocupando que si te fijas
aquí está la de netflix eureka para
convertirlo en un servidor y las demás
dependencias que hemos estado trabajando
va se agrega esta parte de configuración
para que no corran las pruebas unitarias
todo lo que hemos estado trabajando en
los pomps va y finalmente nuestro archivo
de configuración que es este y pues es
lo mismo no ahí te dice cómo traes del
repositorio perdón del microservicio que
está en el puerto 88 88 que es el config
repo perdón el config server de ahí va
a traer sus archivos de configuración si
los encuentra le estoy diciendo que este
es servicio de eureka levante en el 87 61
y la configuración para que no se se tome
como un propio cliente y por último en
nuestra clase main va a anotar la
utilizar la dependencia en la eureka
server para que se trate como un
servidor va cuando tú levantas esto
te va a dar una url que es esta en el
87 61 que corresponde a lo que levantamos
acá no en este puerto y si tú le das
clic ahí te va a llevar a esta esta
interfaz que te decía que que realmente
es una interfaz gráfica y este se
eureka esto se eureka va entonces yo le
voy a dar aquí un refresh yo al bueno al
irlo configurando uno por uno no va a
saber todo esto vacío no yo aquí ya lo
muestro completo porque yo ya tengo
conectados todos los servicios y te fijas
aquí está conectado en la pguey y están
conectados los otros dos no estos estos
los otros tres estos vendrán a ser
clientes de eurek y si te fijas esto que
viene a hacer es el nombre es el nombre
de cada microservicio lo que les
comentaba va y además te va a dar
un estatus de monitoreo de cómo están
las instancias o sea además de
registrarte el servicio te va a registrar
todas las instancias que tienes y este
la en donde están corriendo va entonces
en este caso aquí se muestra que tienes
una instancia si tuvieras más tráfico
haría balanceo de carga te va a mostrar
cuántas cuántas instancias tendrías y
las ligas para administrar cada instancia
va entonces esto es básicamente el
servidor de eureka es más especializado
sí para gente que se dedica al monitoreo
toda esta gente de devops no nosotros
como deps pues nos sirve ver que tiene
una interfaz gráfica que hace esto y
sobre todo su uso que es para el tema
del descubrimiento va en este caso que
lo vamos a estar ocupando así entonces
esta es la parte de cómo se configura el
servidor y bueno creo que creo que no
tiene mayor este complejidad la otra
parte es cómo se conectan los otros
microservicios que vienen a ser pues
los clientes va entonces es lo mismo
nada más que vas a agregar en vez de la
dependencia de eureka server la
dependencia de eureka client en todos
los micros en este caso vimos que está
el gateway el producto el usuario el de
órdenes ahí vamos a instalar esta
dependencia en maven y le vamos a decir
la configuración para que se vaya a la
url del 87 61 que es en donde está
corriendo nuestro nuestro servidor de
eureka va eso es básicamente todo lo que
se tendría que hacer y obviamente pues
también en la clase main habilitar el
descubrimiento como clientes va igual
está está librería o esta notación está
disponible porque nosotros instalamos
pues las dependencias de netflix
y cuando ya bueno aquí te dan un
último paso que es acceder a este local
host que es lo que ya vimos y ves la
la interfaz gráfica de eureka entonces
eso mismo se hace igual voy a agarrar el
mismo microservicio que es el de
productos nosotros también ya lo tienen
este pero bueno yo por fines de que
he estado agarrando este lo voy a
mostrar aquí y es lo mismo lo que
veíamos en el pom este por ahí va a
estar la librería es buscarla y vas
a encontrar el cliente de netflix esto
lo va a hacer que esté esta librería va
va a poder meter la notación en la clase
que estamos buscando que es en nuestro
main esta es la notación del enable
discovery client para que se comporten
un cliente de de eureka y la también
importante decirle en dónde está este
en donde está mapeando ese servidor va
con esta configuración yo le digo que
se vaya esa url y en este puerto que
está corriendo en este host que es el
local está corriendo la instancia de
eureka y con eso yo bueno y la otra
propiedad creo que es también muy muy
importante está va el name entonces yo al
darle un name y así voy nombrando cada
uno de ellos este eureka hace ese
mapeo y sabe quién es quién por su name
por su nombre entonces esa es la parte
de descubrimiento y bueno eso es lo que
lo que propone eureka ahorita también
una aplicación práctica la vamos a ver
cuando veamos el uso de el cliente del
fein client para que podamos ver cómo
se conectan por medio del del name y
pues bueno aquí vemos la interfaz de
eureka va entonces eso es básicamente
lo que trae eureka ribbon balanceo de
carga que de hecho aquí es el siguiente
punto pues nada más es este como
se se está ocupando no lo bueno como se
a nivel teórico cómo funcionaría el
balanceo va entonces no sé si hay alguna
duda con esta parte de lo que es eureka
cómo se configura para qué sirve cómo se
cómo se ocupa cuando menos en esto el
descubrimiento este creo que fue fue fue
muy sencillo no la configuración y ahí
viene pues en la en la en la presentación
pero bueno de todos modos se fue
mostrando clase por clase no sé si haya
alguna duda algún comentario que tenga
perfecto súper sale entonces sí creo que
esté esta parte de esta más este más de
configurar y no hay tanto problema
bien entonces si no hay dudas continuamos
con la parte del getaway sale
entonces igual el bueno vamos a regresar
tantito es la 68 si regresamos a nuestro
diagrama vamos a ver si se guardaron ahí
los rayones que hicimos que creo que no
bueno este ahí también ya vimos la parte
de eureka no a ver vamos a hacer una
remembranza creo que es con esta
entonces hemos estado viendo ya la parte
de cliente con posman ya vimos la parte
de eureka no el descubrimiento vimos este
la parte de cómo nuestro bus está
funcionando en cada uno de nuestros
microservicios hemos estado viendo la
parte del config server hemos estado
viendo la parte de los config repo y va
hasta aquí estaríamos cubriendo esta
parte ahorita vamos a ver cómo entra el
getaway va entonces vamos a ver cómo se
configura el microservicio gateway y
entonces es la parte que sigue entonces
sería en la 68 nos quedamos
vamos a ver 68
entonces el api getaway entonces una
definición burda de un getaway
tanto ustedes como yo ya lo hemos
trabajado un getaway es es una es una
puerta hacia la hacia el microservicio
bueno hacia hacia hacia alguna
aplicación entonces los getways sirven
como entre otras de las cosas de dar
orden a las peticiones y demás
y también te ayudan a implementar este
mismo el balance de carga
entre otras funciones que tienen los
getways también está el tema de usarse
como filtros no entonces tú puedes hacer
que una petición se intercepte entre un
cliente y un aplicativo pasa por tu
getaway y en este en este sentido el
getaway podría aplicar filtros sobre
esa petición podría hacerle
transformaciones lo que quieras y
después ya que esté procesada primero
por este getaway ya la puede mandar al
aplicativo no entonces como una capa
adicional a la petición
este esto es lo que lo que te
permitiría hacer un getaway va entonces
dentro de tus funciones también están
como decíamos el controlar el tráfico
este por medio de balance de carga
aquí igual en la diapositiva esto
quiere decir que igual es un micro
servicio entonces vamos a crearlo desde
la interfaz de spring initializer vamos
a agregar la metadata todo lo que ya
hemos estado trabajando vamos a llegar a
un a un proyecto lo subimos a github
creamos sus ramas este y en este en este
micro servicio igual vamos a tener la
las dependencias vamos a instalarle en
negrito se ve la que vamos a ocupando
que es esta del starter getaway para que
se comporte ese micro como como un
getaway de spin cloud
cuando ya terminas de crearlo vas a
tener igual das de alta una configuración
en un archivo aplicación yamel
le vas dictando las propiedades que se
ocupan esto por ejemplo para el tema de
eureka
le vamos a ir diciendo que este se
habilite la el descubrimiento que
se haga por medio de eureka y le vamos
a estar pasando esto creo que es lo más
importante las rutas de todos los
microservicios hacia donde él tiene que
interceptar por así decirlo donde él
tiene que fungir como puerta de entrada
entonces si tú te fijas todo esto es
son los user son los names perdón de
cada micro servicio cortesía de de ureca
no ya por medio de ureca ya puedo decirle
simplemente que que se llamen así y va
a entender a qué micro servicio se tiene
que conectar y además va a saber que qué
u rl debe de aplicársele para que la
proteja en este caso esas u rl se dictan
por medio de una notación que se llaman
predicados y en este caso yo le estoy
diciendo que prácticamente todo lo que
venga desde el pad y user se acuerdan que
esa ese pad se configuró en los
controladores no de cada uno de los este
de cada uno de los microservicios en este
caso estoy hablando del pad de user de
producto y por ahí está el de order en
esos pads todo lo que venga después de
de eso en de este pad en esa u rl
es lo que va a cubrir el el gateway
prácticamente todos los endpoints que
creamos que son el get all el get by id
el post el put del delete todos esos los
va a estar interceptando el el el gateway
va en cada uno de los microservicios que
estoy diciéndole entonces la configuración
más este probablemente más importante
que es la que hace que funja como como un
gateway se le configura además el puerto
en este caso este este este este
el gateway va a correr en el 8083 y de
igual forma le decimos que agarre la
configuración de eureka va el
descubrimiento se está conectando icon
eureka e también en la clase main va que
ya la tenemos bien identificada vamos a
decir esta propiedad va la de la de
discovery por por eureka la que hemos
ya estado manejando entonces eso es todo
lo que se tendría que configurar en el
gateway y pues ahora vamos a revisarlo en
la parte del gateway lo mismo desde
spring inicializer me creo mi proyecto
va ya que lo tengo me va a dar las
configuraciones básicas y siguiendo la
presentación pues yo le voy a ir
metiendo sus configuraciones va entonces
en este caso aquí yo voy a decirle que
se vaya primero a acá y al pom vamos a
revisarnos entonces en el pom yo aquí
tengo todas las dependencias para que se
comporte como un gateway va este eso es
en la parte del pom este pom pues
obviamente va va creciendo conforme le
vayamos metiendo este configuración de
dependencias entonces este es el pom
aquí en nuestra clase main lo mismo
habilitamos el descubrimiento de de de
servicios con con eureka va como lo
tratamos como un cliente de eureka y
nuestro archivo de configuración en la
aplicación yamel lo que te decía no
aquí le damos un name lo bautizamos y
le vamos a decir que
estas son las rutas que vamos a estar
este interceptando por así decir no
entonces va a estar interceptando rutas
que vengan desde usuario desde producto
desde orden aquí tiene otras de otros
micros que también se ocupan pero bueno
esto esto para nosotros no no funciona
no lo de car y lo de se nada más basta
tener usuario producto y orden que son
las que hemos estado este ocupando va
esto es lo que haría que intercepte esas
peticiones y bueno todo lo demás lo
vamos a ver ahorita porque es la parte
de la seguridad
y bueno le estamos diciendo que corran
el puerto 80 84 y que se conecte al mismo
cliente de brek va entonces cuando yo
levanto este get wey vamos a ver qué
más nos dice aquí la presentación
bueno y ya es la parte de fein
para hacer eso ya con eso nosotros no
tenemos que configurar nada más a
levantarlo yo voy a tener a no cierto
hay otra hay otra parte que es la clase
de configuración va esta esta clase
creo que no está en la presentación no
la vi y igual y otra hacemos la búsqueda
pero bueno esto básicamente también se
tiene que agregar aquí en el get wey un
paquete que se llama config metemos esta
clase que se llama security config a ok
ya ya recordé es que esto se mete pero
cuando se configura con con el servidor
de autenticación entonces esto todavía
está bien que lo viemos no lo no lo vemos
simplemente así entonces ya teniendo eso
y yo levantando el proyecto
yo aquí en posman ya voy a poder tener
mi colección bueno de hecho ya la tienen
aquí en get wey ya van a poder acceder al
van a poder acceder a los mismos
en points que nosotros tenemos de
producto de órdenes de usuarios pero
ahora pegándole a través del get wey
por ejemplo si yo veo el endpoint de de
productos así es como se vería este
endpoint de productos y te fijas ahora
entra por el 80 84 lo que antes si yo no
lo cubría con un get wey entraba por el
80 82 entonces ahorita que ya está
levantado el puerto de del get wey yo le
puedo hacer una petición igual a
productos pero esta vez yo estoy
apuntando directamente desde el get wey
y si te fijas ahí me sigue respondiendo
la petición igual la vamos a ver acá en
el en el producto service no aquí entró
la petición aquí también cayó de hecho
si no mal recuerdo se tendría que pintar
de hecho aquí está otro hola porque
volvió a caer en ese endpoint que
estábamos probando entonces ahí aunque
entró por el get wey lo redireccionó
hacia este microservicio de producto y
entró al get wey primero porque si te
fijas aquí entró por el 80 84 va que es
como le dijimos que entre la petición y
por qué lo mapeó porque aquí nosotros le
dijimos que agarrara todo lo que se
encuentra en product service en la ruta
que cumple con este predicado es decir
que cumple con products lo que sea no
entonces al tener ese products lo que
sea que si te fijas eso se ve aquí en
el en la url products lo que sea por eso
es que está haciéndose ese mapeo va
entonces a ver vamos segundo
este mensaje listo va entonces este
bueno esa es la parte de cómo cómo
funciona el get wey va y entonces ya lo
sé en points que teníamos nosotros
expuestos desde digamos desde el
microservicio directamente también ya
podemos entrar desde la parte de su
get wey va así es como como está ya
mapeándose y listo es esa parte la tema
del get wey no sé si ahí quedó alguna
este alguna duda de cómo se configura o
cómo se ocupa
así
exacto si son notaciones grandes que te
pide la el framework o sea lo buscas en
su documentación y te pide eso no te
pide dar un id exacto la uri y el
predicado bueno o sea tú no es que
necesites un predicado le puedes decir
directamente cómo mapearlo pero yo lo
muestro de una forma así con este
predicate porque así es más dinámico o
sea aquí yo englobo todo lo que venga
dentro de este pacto entonces es más
engloba más es más general va
en cual así claro si si si si te fijas
todos estos también coinciden con el
name que les damos a cada microservicio y
todo esto es porque eureka como están
conectados con eureka así es como por
medio del name saben quién es entonces
esto es más que nada el name que se le
da en la propiedad a cada microservicio
por ejemplo ese user service lo vas a
encontrar en en el properties en su
name acá lo tienes
ahí está vale y además también este por
ejemplo en el controlador ya que estamos
aquí podemos revisarlo si te acuerdas
aquí viene mapeado este map entonces
entonces este users es el que se está
ocupando como ruta base para que el
gateway sepa esto que todo lo que venga
acá está está está mapeado con ese va
lo mismo en productos mismo en órdenes
sí sino de que alguna otra duda o aporte
va que va perfecto bien entonces si no
hay más vamos a continuar con el
siguiente punto que es
la parte de los clientes rest con fein
si te fijas ha sido más como temas de
cargas
y
no
no
no
no
no
no
pues viene la parte de los clientes rest
con fein client que es una librería fein
como tal es una librería no es un
microservicio entonces vamos a estar
descargando esa librería en cada
microservicio que lo queramos ocupar en
este caso por nuestra práctica que
tenemos aquí este propuesta lo que les
platicaba ayer no se va a activar el fein
en el microservicio de órdenes porque él
si necesita conocer hacia dónde
y él sí necesita conocer antes de hacer
un insert en las órdenes él sí necesita
conocer usuarios y productos no para que
yo pueda dar de alta una orden entonces
al hacer eso ya te está diciendo que si
necesita conocer productos y usuarios
pues necesita conectarse con ellos para
eso se ocupa esta librería fein
fein client nos va a permitir desde
el microservicio de órdenes ir a los
otros dos micros y extraer información
y en base a esa actuar va con con con
en nuestro en nuestro microservicio que
los mando a llamar
entonces lo primero que hay que hacer es
añadir la dependencia que es esta de
open fein sale esto lo vamos a meter
aquí en el microservicio de órdenes
vamos a modificar la clase main para
habilitar los clientes fein que vamos
a ir declarando si
después vamos a agregar el fein el fein
client se llaman así fein son clientes
se llama el fein client de productos o
sea vamos a hacer una un cliente que se
comunique con el microservicio de
productos y si te fijas este este cliente
es tan sencillo como crear una clase va
decirle que aquí en el no va a decirle
que aquí en el microservicio de órdenes
que vamos a agregar el fein client
y vamos a agregar el fein client de
productos y si te fijas este cliente
que va a agregar el fein client de
productos y si te fijas este cliente
que va a agregar el fein client de
productos y si te fijas este cliente
que va a agregar el fein client de
productos y si te fijas este cliente
que va a agregar el fein client de
productos y si te fijas este cliente
que va a agregar el fein client de
productos y si te fijas este cliente
que va a agregar el fein client de
productos y si te fijas este cliente que
va a agregar el fein client de productos
y si te fijas este cliente que va a
agregar el fein client de productos y si
te fijas este cliente que va a agregar el
fein client de productos y si te fijas
este cliente que va a agregar el fein
client de productos y si te fijas este
cliente que va a agregar el fein client
de productos y si te fijas este cliente
por medio de fein client desde
órdenes hacia usuarios
le estamos pasando la variable
como parámetro
y listo al microservicio que se
llama de esta forma
esa es la parte de cómo funciona nuestro
fein client
ajá
y eso lo vamos a ver reflejado
en este método de create order
va lo que les decía
cuando yo quiero dar de alta una orden
primero necesito conocer si hay
si el usuario que me están pidiendo existe
y si hay productos
entonces esto es lo que estaríamos
haciendo en el en la
programación del método de creación
órdenes estaríamos
esto lo vamos a revisar también en el detalle
ahorita pero aquí igual y
se puede ilustrar lo que
hago es instanciar
en un DTO
de usuario y de producto la llamada
del cliente del fein client
de cada uno de ellos
entonces lo que me llega por
en la orden ahorita vamos a ver cómo está
compuesto ese ese request
yo le digo
le mando el id de usuario y el de
producto y con eso el cliente del fein client
a cada uno de ellos va a
responder
si encuentra información en alguno de esos dos
este más bien
aquí si no la encuentra manda
esta excepción de que no existen
los productos
y en caso contrario pues los voy a
los voy a llenar y voy a hacer la
la devolución de la de la orden
va entonces
eso es como se estaría viendo vamos
a ir vamos a ir ahora configurando
paso a paso
entonces para eso nos
decía aquí la presentación
lo primero que hay que hacer es
añadir la dependencia
que es open fein en
nuestro micro servicio entonces
en este caso se refería al micro servicio de
órdenes si te fijas
en orden
voy a ir cerrando todo esto para que no nos haga
ruido y lo vamos a ir abriendo conforme
se ocupe aquí
en el en el
voy a utilizar la librería de
open fein entonces
si yo la busco
aquí está
y al hacer esto bajo la dependencia
y ya está listo para que pueda ocupar las
las librerías va
entonces en paso uno en el paso
dos la clase main
y ahora tengo que
habilitar los clientes fein que yo vaya
que yo vaya a crear
va entonces igual esta librería
yo lo puedo importar
porque ya la agregué al
al maven ya bajen las
dependencias y demás
luego
con esto
ya tendríamos
este
habilitado la
parte de los fein client ahora ya
nada más habría que crearlos va
entonces para eso si te fijas este
microservicio de
de órdenes hay que crear un paquete
nuevo que son los clients y
dentro de esta carpeta o
paquete vamos a crear dos clientes
que es el de producto y el de usuario
va
tan sencillo como crear estas
agregar estas líneas que creo que son bastante
intuitivas va
vamos a crear el cliente de producto
lo que hago es decirle
que microservicio se va
lo puedo agarrar por medio del
name va le digo al de
product service le digo
a que url le tengo que pegar
que es la que se llama
products ID va
entonces esto se va a ir al
controlador de productos a este
endpoint que básicamente es el de
product by ID y
paso este parámetro
y la respuesta por eso les decía que
este microservicio de órdenes ocupaba
el DTO de producto y el de usuario
va entonces esto es
el mapeo esto es lo que me va a devolver
ese cliente un ID un nombre
y un precio que esto
está mapeado pues con
los clientes de con los DTO de producto
y el de cliente va es el mismo
que tienes en dado de alta en esos
microservicios entonces
tú haciendo esto
ya tienes un mecanismo que hace peticiones
hacia esos microservicios
va tanto producto
como el de usuario
y finalmente nosotros
nos vamos a la clase de los
controladores aquí
en el de orden y en el
método post que es
la creación de la orden
si te fijas este también tiene el mismo ejemplo
de traer la example property
de su config repo
todo eso no como
para que nos vayamos familiarizando
y si te fijas
aquí en el post
vamos a buscarlo
este es el put, este es el get, este es el post
en el post
ahorita no le hagan caso al circuit breaker
en el post
yo tengo el método de creación
de orden me llega la
petición el body
de la petición para crear
una orden me va a
pedir básicamente el ID del
usuario el ID del producto la cantidad
y la fecha de la orden
eso lo vamos a ir viendo ya también
aquí en el postman si yo
abriera la colección
de órdenes para crear
una
yo aquí tengo y esta es la petición va
entonces voy a órdenes le voy
a hacer un post voy a dar de alta
una orden y en el body yo le voy
a pasar esto le voy a decir
este al
usuario 2 le voy
a pedir el producto
y le voy a pedir 2 y le voy a pedir
3 no 3 de ese producto
la cantidad y en
esta fecha
el formato si yo al mandar esa
petición me va a responder
ya sea que si existe
ese usuario y ese producto
que si se acuerdan también
tenemos los métodos para consultar
el user por ID el producto por ID
si esos existen
la orden se va a completar
va entonces ahorita vamos
a hacer el happy pad en donde si se inserta
porque cuando no se inserta
es cuando vamos a hacer la ilustración del circuit
breaker que es lo que les decía de que
si algo falla el circuit
breaker va a estar ahí disponible
para que eso
no suceda no se rompa
el flujo entonces viendo
el método si nosotros
nos vamos a la programación
aquí
en el order service en la creación
de la orden lo que
vamos a hacer es verificar
que exista ese usuario
y ese producto que nos están pasando
por el request
es decir estos el ID
de ese usuario y ese producto lo vamos a validar
que primero exista en
los otros dos micros entonces para
eso me hago uso por inyección
de dependencia del cliente que
acaba de crear esos clientes son
estos se les llaman clientes realmente
son los fan clients
estoy usando estoy importando estas
librerías acá o bueno estos métodos
estas clases por inyección
y le estoy diciendo
que aquí en el
crear orden me lo
traiga no lo estoy usando
estoy diciendo tráeme un user tráeme un
product por medio de lo que llega
en la petición de orden en el
user ID y en el product ID
que es lo que llega acá
estas estas dos
propiedades entonces al hacer
eso estos este
DTO se van a llenar y si
uno de ellos
dos es nulo pues aquí me va a mandar
una excepción va
una excepción controlada en caso
de que no la mande
este
a ver nada más un momento
dos minutos
un segundo
me tardo
listo
ya una disculpa
entonces este si aquí
uno de estos dos estuviera vacío
manda una excepción controlada
y manda este mensaje de lo
contrario la orden este se
crearía y se guardaría va
entonces vamos a hacer este happy pad en donde
todo existe y
si se puede dar de alta como para corroborar
que todo esté bien
entonces yo voy a mandar aquí mi
usuario dos
porque primero vamos a consultarlos voy
a ver si el producto dos existe
que de hecho ahí ya hice la petición varias
veces existe ahora voy
a checar en usuarios
si existe lo puedo
buscar por ID o
por un get all user
si yo le digo que me mande el
tres ahí lo veo le hago la
petición y también existe entonces
al momento de yo crear la orden
es decir hacer el post
de la orden mandándole
el usuario dos y el producto
dos con la cantidad tres
antes de eso quiero mostrarles
el get all orders si se acuerdan
de nuestro
archivo de
de ml
en órdenes
también insertamos órdenes
por default entonces
vamos a abrirlo nada más como para recordarlo
vamos a abrir
en el SQL
en la de órdenes
en la de manipulaciones los archivos
de manipulación te fijas aquí
también me dio de alta ciertas órdenes
igual ahí
no di de alta el
el ID simple y sencillamente
le dije que usuario que producto
y con eso este
me los fue
dando de alta entonces si yo hiciera
un get all de esas órdenes
me las va a responder
me debe de responder tres órdenes
que son las que existen ahí
por default por así decirlo
eso se mapea como la
orden con ID uno
fue de una cantidad
dos
para el
usuario uno
el producto uno y ya
en esta fecha
esa es la relación que se crea entre orden
producto
y usuario es esto
y bueno entonces si yo
diera de alta una nueva orden
ahí está el endpoint se me borró
lo vuelvo a agarrar
entonces si yo fuera a dar de alta una nueva orden
yo la envío
vamos a tener un nuevo
identificador en las órdenes que es el
cuatro que de hecho aquí ya se dio
de alta si yo hiciera aquí un get all
orders otra vez
aquí nada más nos devolvía tres ahora ya
nos debe de devolver cuatro que es el
último registro que cree
va entonces este mismo
ejercicio
es el que hemos estado manejando con producto
y con usuario
que es el crud o sea aquí
aquí está el crud
ahora de órdenes
y este crud es está un poquito
más elaborado porque conlleva
esa relación entre
producto y usuario
es eso
entonces este
bueno esta es la parte de cómo
se conecta así es como se ocupa el
fame client no sé si hay alguna duda
sobre
sobre este
sobre cómo funcionan los clientes
para que se ocupa para que es la librería
en la codificación no sé
algo
adelante
para usarlos digamos
digamos solos sin necesidad
de
en nuestro ejemplo
sí pero en la parte
teórica te decía cómo
cómo el spring framework
es eso es un framework
modular puedes ocupar cualquiera
de esas piezas por separado
y no va a tener problema
ok
ok si básicamente
es con el con el con la propiedad
name donde está
ah bueno déjame ver el cliente de
de
en donde lo configuramos aquí verdad
este ok estos
clientes este simplemente
nosotros mapeando esta
esta configuración y habilitando
en la clase main
los
cómo se llaman los
los la el fame client
con eso ya podrías este
utilizarlo esto dentro de nuestro
ejercicio que tenemos eureka
que tenemos este
el gateway va
cuando tú no tienes esa parte
si si tendrías que hacer uso
de del dominio
del del microservicio
donde estás apuntando o sea literal
le puedes pasar la url así
tal cual completa
como viene como te la den
y a esa url es a donde tendrías
que apuntar aquí en el
fame client hay una propiedad
no me acuerdo cómo se
especifica pero tú le puedes decir la
url la url va
entonces nosotros estamos haciendo esa es una muy
buena pregunta nosotros estamos haciendo
configuración
por medio de names va
como les decía todo está bonito
cuadrado por las propiedades de los names
pero también puedes hacer una configuración por medio
de una uri va entonces no me
acuerdo aquí cómo es la notación no era
mi intención mostrar ese ejercicio
pero creo que por ahí puedes
definir una propiedad es cuestión
de también meterlos en las librerías
y setear ahí la
uri no la url y ya te
evitas directamente agregar el
name ya te
puedes ir a cualquier servidor
así si claro
correcto si
claro
si
si de hecho yo hice un mapeo
simple para ilustrarlo
porque si te fijas este es
un get hacia producto
por id pero yo también puedo traerle
todos los productos sin
pasarle un id osea yo puede haber
hecho aquí otro cliente osea si te fijas
estos clientes fein son
el mapeo
de los crud o de
los métodos de los endpoints
que exponen cada controlador en
cada micro servicio
si te fijas este es el endpoint
que le pega al get product by id
pero yo también puedo tener este de
get products y decirle
que se llame así
y no le pasó nada
porque no ocupa ningún parámetro
y con eso ya estaría yo haciéndole una
petición al get all products
y este es
el mismo mapeo que yo me voy
al que si yo me fuera aquí
al product service a donde está su
clase controladora
y aquí tengo su products
by id get all
products que creo que era este
aquí le estaría pegando yo a este
a este método
ah bueno aquí tendría yo que ver
que si te fijas aquí tendrías
que devolver una lista
de SDTO
entonces yo aquí tendría que llevármelo
también aquí en el de order
o sea yo puedo crear una colección
de mi cliente
fein con tantos métodos como yo ocupe
relacionados a este
servicio entonces yo con esto al mandarlo
a llamar estaría obteniendo toda
la lista de todos los productos
está pegando a ese endpoint
también yo podría hacer
por medio de fein client
el delete el update todo
eso va
en este caso se ilustra
el uso del
id de bueno de este endpoint
pero si puedes ocupar el
método que a ti se te ocurre
bien entonces bastante bien
alguien más alguna
duda pregunta inquietud
sobre el uso de los
fein clients
bien entonces todo claro
curioso que siempre acabamos
el pomodoro al
en el número ocho no 58
va entonces vamos a tomar
el siguiente pomodoro que es el tercero
hasta ahorita hemos tomado dos verdad
uno dos tres
va entonces en este
en este este
en este pomodoro vamos a
agarrar 25 minutos
para
para ir a despejarnos y
regresando este es el que no tomamos ayer
regresando este
continuamos viendo la parte ahora de
los circuit breakers vamos ahora
a ver como cuando la petición
vamos a forzarla por allá que
y cuando esto falle
este
vamos a
vamos a ver como cae en un fallback
circuit breaker para que
no se no se truene
el flujo siga vivo
y con eso pues ya este
la petición no se pierda
va entonces es el siguiente tema
la parte del circuit breaker
y entonces nos vemos aquí a las
doce veinticinco
tomando esta práctica
del pomodoro va
les parece bien
listo
vale entonces nos vemos ahorita
doce veinticinco
les les vuelvo aquí a hablar
va
listo
bueno bueno
escuchan
listo
vale entonces vamos
a continuar voy a compartir pantalla
va
avisan si se ve por favor
ahí se ve no
perfecto
tal y vale entonces
eh continuando
con la
presentación
habíamos visto lo que es el tema de
los fain clients
aja ya vimos como
se implementó en el
ah permítame voy a agregar alguien más
listo
entonces ya habíamos visto como se implementó la
librería de fain en este micro
servicio en el de órdenes
y con ese este pudimos
traer productos
pudimos traer
este usuarios
y en base de que existaba
si existían los productos y el usuario
se podía se podía crear la
la este
la
la orden no se creaba
la orden
se vio como se
iba haciendo una un repaso
así rápido
se vio como se configuró el
fain client en el micro servicio de
órdenes añadimos la dependencia
se abrió este
mecanismo esta anotación en la clase
main
se crearon los dos fain clients
de usuario y producto incluso vimos
que se podía crear más de un método
en un solo cliente y
que correspondían a los
que existen en cada
controlador de cada micro servicio
este ahí
se vio el método de crear orden como
se ocupan esos dos clientes
y dependiendo de si existe uno
registros lanzar una excepción o
crean la orden va
por su totalidad
ahora
vamos a aplicar una
nueva librería que se llama
que bueno realmente no es
la que vamos a usar vamos a usar otra
este
pero bueno al final esta librería
ocupa
igual que esta nueva que estamos ocupando
es resilience 4j
estamos ocupando
un este
un patrón de diseño
que se llama circuit breaker
o corto circuito
que básicamente lo que hace es proporcionarnos
un método que se llama o se conoce
como fallback
y en este método se va a detonar
o se va a ejecutar
si y solo si cuando sucede
alguna falla de comunicación
entre los micro servicios
en este caso se ilustra bastante
bien su uso con la librería
feinclient
porque si en algún momento la comunicación
fallara entre nuestros micro servicios
utilizando
ese disjunctor
que es esta librería
resilience 4j
estaríamos aplicando ese patrón de corto circuito
la petición no se muere
y en vez de que caiga una exception
cae más bien dentro
de un método fallback
que nosotros dentro de ahí podemos ya hacer lo que
queramos podemos hacer por ejemplo
que la petición si
por ejemplo queremos crear órdenes
pero se cayó el micro servicio de productos
que por ejemplo mande
un correo electrónico
al cliente que lo quiso
comprar esa orden
donde le dices que por ahora
no puedes procesar su orden
pero se procesará con más
en un tiempo
muy corto algo así
que lo retomaran en
poco tiempo o incluso
si por ejemplo se te acabo el
bueno eso es otra cosa
que se te acabo el producto
porque ahí no se murió el servicio
simplemente se acaban los productos
más bien es cuando existe una falla
se cayó por alguna
razón los de infraestructura le movieron
algo no sé se murió
el micro servicio por algo un despliegue
anterior provocó un cambio no sé
se murió y entonces
hoy en la mañana en productivo
están las órdenes a todo lo que
da pero pues no se procesa
porque no se cayó el micro
servicio de productos no entonces
podemos hacer por un escenario
ese ejemplo podemos hacer
que las peticiones aún sigan
llegando no que hacemos
mandamos en ese fallback el correo
al usuario de tranquilo
te voy a atender en poco tiempo
este y
a lo mejor
incluso esas peticiones irlas guardando
ya sea en un log o lo puedes guardar
en una base de datos o lo puedes
enviar a Kafka ahora sí usarlo como
broker no como
mensajero lo metes
al encolado y cuando otra vez vuelve a estar disponible
las vuelves a procesar
o sea puedes hacer lo que tú quieras
lo que se te ocurra
o también no puedes hacer nada
dependiendo pero bueno
obviamente la idea es agregar un circuit breaker
pues para que
se
se vaya generando el
para que se vaya generando el
bueno la petición
para que no se muera
entonces
este
ese concepto no sé si
queda claro hay alguna duda
de lo que es el
el patrón del cortocircuito
la librería que vamos a ocupar
en donde se ocupa
para que
no sé si eso más o menos queda claro
perfecto
sale vale
entonces
bien
para añadir ese patrón o esa
librería vamos a agregar igual
en los archivos de configuración
bueno más bien aquí en el pump
vamos a agregar primero la dependencia
en este caso seguimos trabajando
con el microservicio de órdenes
porque bueno ahí es donde hicimos la comunicación
con feinclient
entonces vamos a agregar esta librería
esta dependencia en maven
que es el resilience4j que les decía
y bueno
se llama así no circuit breaker
resilience4j
esta es la dependencia que hay que agregar en el maven
de órdenes
la voy a copiar para ahorita hacer la búsqueda
y
también vamos a modificar
este
en el método de
crear orden que es el que acabamos
de desarrollar
que programamos hacer
el pomodoro pasado
vamos a agregar un mecanismo
que implementa esta
librería que es el circuit breaker
va entonces con esta anotación
nosotros le vamos a decir cómo se llama
el circuit breaker
y le vamos a estar
pasando o seteando
un método
que se llama fallback
para en este caso para crear orden
así lo vamos a llamar al método
y con esta etiqueta
dentro del método
de crear orden
ya la librería en automático
va a entender que cuando ocurra
algo que falle por una comunicación
va a pasar
por este fallback
entonces ahora vamos a ver cómo se crearía
ese método fallback
y de hecho aquí está
se crea de esta forma lo que va a hacer
en este caso el ejemplo que hicimos
es que
aunque existiera una falla
nosotros vamos a devolver un objeto
de order por default
seteado en propiedades vacías
un id
menos uno un producto menos uno
o sea yo voy a setear un objeto
por así decirlo
dumy y lo voy a devolver
eso como para que se vea que
se puede hacer cualquier cosa realmente
en este caso yo voy a poner este ejemplo
y listo
esa es la parte del circuit breaker
no es tan compleja
ahora vamos a ver cómo se
como se desarrolla
si nosotros nos vamos al microservicio
de órdenes
que es donde hemos estado trabajando
voy a buscar aquí otra vez voy a cerrar
toda esta parte
como para irlos abriendo
conforme ocupemos
voy a abrir el
archivo pump
que es en donde he estado agregando
mis librerías, mis dependencias
y aquí voy a buscar
la que se llama resilience 4j
que es esta
la instalo
bueno más bien agrego la dependencia
bajo los proyectos de maven
los actualizo
y cuando eso suceda yo aquí
en mi controlador
ahí voy a poder hacer uso de esa
anotación
esa anotación
de circuit breaker la voy a poder
utilizar acá
entonces aquí en mi método
de crear orden
este
es en donde
yo tengo mi mecanismo de
feinclient ahí es donde yo lo
configure y si te fijas
aquí le estoy diciendo con esta anotación
con el circuit breaker
que se llama de esta forma
que cualquier cosa que ocurra
en caso de una falla
se vaya a este método de fallback
este método lo encuentro acá
entonces esto lo que
vimos que hacía es básicamente
devuelve un objeto
de orden vacío
un objeto de orden
nulo o por default por así decirlo
un objeto default
que no trae nada de información
y nada más es como para que
pues se ilustre que se puede
enviar cualquier
cosa
entonces como puedo provocar ese
corto circuito
bueno si se fijan
si recuerdan aquí en la parte de órdenes
yo puedo yo tengo aquí mi método
de post sale aquí volvemos
a hacerle una petición al get all
nada más como para recuperar
y recordar cuántos tenemos dados de alta
tenemos cuatro con los
que hemos estado trabajando
yo voy a hacer una petición
al micro
servicio de
orden
pero ahora voy a insertarle un usuario
5 por ejemplo
un usuario 5 pues nosotros sabemos
que no existe por nuestro
nuestro endpoint de usuarios yo
aquí consulto todos los usuarios
y obviamente yo aquí veo que nada más existen
tres entonces incluso un usuario
4 un usuario 5 pues no existe
entonces ahí es donde podría
producirse un corto circuito
porque cuando yo intenté hacer una orden
de un usuario que no existe
pues ahí debería manejarse
una un problema
habría una
una excepción pero si tú te fijas
aquí la petición sigue
siendo exitosa la
respuesta sigue siendo exitosa
y si tú te fijas aquí estamos
mandando un objeto
dumi o genérico de una orden
esto obviamente
la respuesta puede ser la que
tú quieras en el escenario ya lo
pudimos no podemos enviar correos
podemos enviar enviarlo
encolarlo a Kafka podemos hacer
guardarlo en la base de datos como fallidos
guardarlo en logs no sé
lo que se te ocurra aquí por
el ejemplo práctico pues creamos
un objeto dumi de esta parte
entonces este
ese es el funcionamiento
de la parte del del circuit breaker
sí y este
y bueno
este otro mecanismo para que
veas que a lo mejor
vale la pena poner aquí
un breakpoint pequeño breakpoint
para que veas cómo va a entrar este fallback
porque aquí si te fijas
no pinte ningún
ningún este ningún log no
pinte nada pero podemos hacer que
este que si
yo le pego y obviamente aquí va a caer porque
va a fallar digo va a entrar en un
corto circuito porque entraba un usuario que no
conoce ahí ya respondió el breakpoint
cuando yo lo pinte
y si te fijas significa que si está cayendo
si está haciendo caso de la
configuración que yo le puse
aquí y le dije que cuando hay algún
problema en la creación de órdenes
caiga en el
circuit breaker
en este método fallback y
de hecho aquí ya caché el breakpoint
ahí lo voy a liberar para que
no de problemas
o no se esté interrumpiendo y pues ya el flujo lo
continuó y no hace más que
devolver este objeto que decíamos que
está este está vacío va entonces
la respuesta sigue siendo
exitosa no se cayó
y bueno estoy haciendo
esta parte va
entonces ese es el ejemplo
ese es el escenario que expone
en los circuit breakers no sé si
aquí hay alguna duda
pregunta algún comentario
algo para
para completar este ejercicio
del circuit breaker
creo que si quedó bastante claro
listo va
entonces si no hay nada con la parte
del circuit
breaker el fallback
hacia donde cae todo esto
continuamos va
y la otra parte
ya quedan solo dos temas antes de
entrar ya en la práctica
la otra parte es el aseguramiento
de los microservicios
es decir que les vamos a añadir
un mecanismo
de seguridad
a nuestras peticiones va
esto no hace referencia
más que añadir
tokens de seguridad para que
cuando nosotros hagamos una petición
todo esto
sea autenticado antes
por un servidor que se va a encargar de esa parte
de gestionar los tokens
y si la petición
entonces es válida
o ese token es válido
entonces la petición se va
a resolver
de lo contrario pues no lo va a hacer
va
entonces
esa es la parte que ofrece
la seguridad
y
bueno vamos a estar viendo como se configura
que dependencia se ocupa
y sobre todo en los applications
también en los properties como lo vamos
a estar este
ocupando
entonces
vamos a empezar entonces
para esta parte
el paso uno que nos esta diciendo
aquí es este
quien sabe por que sabe así
vamos a estar
usando un servidor
que se llama KeyClock
nosotros al usar este
servidor
le estamos delegando a este servicio
la tarea de gestionar los
tokens va entonces
nos va a estar proveyendo tokens
JWT válidos
y cuando se ocupen
en las peticiones
de esa forma
vamos a hacer que la
va a existir una validación
de autenticación
entonces este KeyClock
va a correr en el puerto 8080
en ese codiciado puerto 8080
va
y para usarlo
aquí nosotros pusimos una
página
que es de hecho la página de documentación oficial
de KeyClock aquí tu puedes entrar
y puedes ver este
puedes ver mas en detalle el concepto
es muy profundo todo lo que hace
KeyClock es open source
por eso lo ocupamos como
propuesta y ustedes pueden ir viendo
que mas trae
no es el objetivo volvernos expertos
en este servicio
lo vamos a ocupar con fines practicos
que es la generación de tokens
entonces
ese es el producto
ahí te muestra
en la página las
guías para que tu puedas hacer la
instalación por ejemplo aquí te dice como se instala
con docker
ahí te dice como crear el primer
usuario el primer token
el primer reino que ahorita vamos a ver esos
conceptos entonces tu ahí puedes estar
echandole un ojo a su documentación
pues ahí sin mayores problemas
va en este caso
yo elegí instalarlo por medio
de docker va entonces
este es el comando que aquí nos ponen
yo lo copio lo ejecuto
en mi terminal
en cualquiera de mis terminales
yo lo
ejecutaría de hecho yo lo ejecuté en esta
otra terminal de acá si te fijas
por aquí va a estar este comando va
el docker run p
no se que xclock ahí te lo
configura ya en automático con un
usuario cuya contraseña es admin
bueno usuario es admin
contraseña es admin y lo está
inicializando en cierto puerto
en el 8080 va cuando
yo hago eso y todo esto
se intenta se termina de instalar
tú vas a ver aquí
estos logs y
aquí en tu docker desktop obviamente
tiene que estar prendido este programa
por eso vamos viendo
cada vez más usos de este docker
desktop no cuando yo lo ejecuto
y lo instalo se me va a abrir
este nuevo contenedor que es el
trusting bar bueno ahí
le va a poner un nombre aleatorio
porque yo no se lo definí y
te va a decir que está corriendo en el puerto 8080
eso
va entonces la primer parte
que tú tienes que hacer y aquí te lo va
a ir diciendo la aplicación la
presentación aquí te dice cómo entrar
al localhost de ese de esa
terminal o de ese front
de ese servidor
entras con este usuario de password
que son los que se dan
se delegan aquí se
enuncian aquí si
y entonces tú lo que tienes que hacer
es agregar un cliente
vas a crear un reino que se llama
gateway service porque se llama así
porque hace alusión al servicio
gateway y recordemos
que en nuestro diagrama
ahí hacemos una pauta estamos
en la 84 si hacemos
una pequeña remembranza
de nuestro
diagrama donde está
ah se pierden
ahora vamos a buscarlo
si nosotros hacemos pequeña remembranza
aquí en el
diagrama que teníamos
a ver déjame lo busco acá está
45 si
nosotros estamos
viendo que el
gateway aquí
ah bueno déjame ver si me puedo hacer zoom
aquí vemos que el gateway
es quien
está conectándose aquí se ve
gateway está conectándose
con kicklock va entonces
nosotros estamos haciendo esta
este ejercicio
en el que kicklock es quien le provee
los tokens al gateway
aja toda petición
que llegue por el gateway
nosotros la vamos a autenticar por medio de
kicklock entonces vamos a hacer una configuración
entre gateway y el kicklock
y cuando eso ocurra
este
las peticiones van a pasar por ahí
y van a
van a poder ver si son este
válidas o no
si la autenticación
se logra o no se logra
entonces en este caso
yo creo
ese reino para mi micro
servicio gateway agrego un
usuario un admin bueno un usuario
con nombre usuario admin
password admin
y el cliente también
lo tengo que cargar y todo esto desde la interfaz
de aquí entonces para hacer
eso el paso uno es
aquí en la presentación viene un objeto
jason en la siguiente lámina
un jason que este esto es
un cliente yo lo que hago es copiármelo
va este es el que vamos a importar
que es lo que nos dice acá
lo voy a copiar lo voy a importar
y me lo voy a pasar aquí a mi
a mi máquina yo aquí
de hecho ya lo lo
lo abrí igual en mi
sublime text y yo
aquí pegue digamos el
el archivo y lo guarde con un
formato jason si
este también se me olvidó dejárselos ahí en la
configuración por eso les estoy explicando como
lo hice y
este
en mi en mi carpeta de spring cloud
ahí yo cree una carpeta que se
llama resources y aquí guarde por
ejemplo este cliente jason
lo único que hice fue copiarlo
de aquí de la presentación
va este cliente
lo copio lo pego aquí en
sublime text y lo guardo
va con este formato client punto
jason el nombre es lo de menos
en la extensión cdbc punto jason
va entonces una vez que yo ya tengo
esto
ya lo puedo utilizar para importarlo
entonces ya tengo el cliente ahorita
lo voy a importar antes de
eso tengo que crear el reino va
entonces aquí desde master
si yo le selecciono aquí
en el drop me dice una opción
create real si
y yo con eso le doy clic y yo diré
nada más le das el nombre
en este caso yo di un gateway service
y con eso ya
este se llama gateway service
y con eso aquí está todo lo dejo
por default le doy crear y ya me
crea el reino una vez
que ya tengo el reino creado me cambio
ahí y yo ya puedo importar
el cliente le doy aquí en
clientes ahí ya me cerro la sesión vamos a volver
a abrirla
admin
y este listo
ya estando yo aquí adentro en el
gateway les decía que en la parte de clientes
le doy en importar client
y aquí es donde yo le digo
buscar y cargo mi
cliente que quede de alta
este al momento de
cargarlo de hecho no pasa nada si lo importo
te va a aparecer eso
y simplemente le das guardar
va se va a llamar user
service entonces cuando ya lo tengas
aquí tú lo vas a poder
encontrar en este caso es este
es una configuración que
trae ahí por default va
el cliente y
finalmente bueno también
tengo que crear un usuario aquí lo único
me dice que es un usuario yo puedo crear
uno que se llame admin admin
no es más que darle en user
y aquí le digo
el username le digo que es admin
va aquí de aquí
lo dejo todo tal cual así le doy
crear y eso lo que va a hacer es
que me va a crear aquí un usuario
lo siguiente es que yo lo voy a
seleccionar y al darle
en editar
bueno más bien lo selecciono
y aquí en las partes de credenciales
aquí me va a aparecer vacío
yo le voy a dar un botón de crear
nueva credencial y me va
a permitir crear la credencial que es la
contraseña
cuando yo la cree la va a
dar de alta esa forma
así la voy a tener entonces yo con eso ya
cumplí con todo lo que me dice
aquí en la presentación ya
crea mi reino ya crea mi usuario
que es admin admin y también
configuré ese cliente
desde la interfaz de KeyClock que
básicamente fue importar el cliente
de acá va
hasta ahí pues creo que es por la configuración
no hay este mayor
mayor tema dale
y el último paso
ya es ahora asegurar el
microservicio que queremos que se conecte que en
este caso decíamos por el diagrama
que es el gateway
entonces en el gateway yo voy a encontrar
en el application yaml
este
voy a encontrar este
estas propiedades
voy a encontrar
estas propiedades y las voy a ir mapeando
entonces no es más que abrir
el microservicio el gateway
si te fijas aquí viene esta
propiedad que dice el security
viene la autenticación
que son los tokens que nos está generando
el KeyClock
que son del tipo OAuth2
y son JWTs
entonces esta es la
esta configuración
aquí lo que haces es decirle que
a que host y a que puerto
a que reino
además en este
nombre se va a conectar
este servicio
para que obtenga de ahí esos tokens
que son de esta
de este tipo
entonces esto
lo vamos a agregar acá en la
configuración si te fijas
voy a abrir el microservicio que se llama
API Gateway
y me voy aquí
a su application
yaml
al properties
y este archivo igual ya
lo conocemos ya está en este
punto yo creo que ya está lo soñamos
y bueno
aquí viene esa parte de
la configuración si te fijas
creo que ya de hecho es la ultima que se le va
a aplicar lo que hace es
decirle básicamente
que se conecta el local host
8080 a este reino que es el que acabo
de crear el GatewayService
y con eso ya está ya lista la conexión
para que se conecte con
Kicklock va
hasta ahí está conectado con
Kicklock
ahora lo siguiente y
último paso creo que son
bueno último paso de configuración
es crear un
paquete de configuración
y una clase que se llama SecurityConfig
voy a utilizar
esta anotación que es el
enableWebFloxSecurity
que todo esto viene gracias
a las dependencias que instale
yo utilizando esta clase de hecho
estoy haciendo un bin
y lo que está haciéndome esta clase
es
ayudarme a
autenticar
es decir que cuando el
microservicio inicia lo que va a hacer
es me va a autenticar todas las rutas
que empiecen
con este patrón que si te acuerdas
es más o menos un patrón como el que hicimos
cuando configuramos el
el otro servicio
que le dijimos
en el Gateway
que le dijimos a donde tiene que
interceptar las
peticiones con los predicados
aquí es algo similar
yo le estoy diciendo que
con este bin
que cuando inicie
por así decirlo
ponga una oreja
en este patrón
todas las peticiones que lleguen por ese patrón
y las voy a autenticar
esto quiere decir que si
esto funciona
el token que me devuelvas
el token oout2
estoy pidiendo el ese recurso
del tipo JWT
y si todo eso
pasa dentro de esta ruta
y si no,
entonces si
si no,
entonces si
si no,
entonces si
si no,
entonces si
si no,
entonces si
si no,
entonces si
si no,
entonces si
bueno, esta es la parte
la última configuración
como vemos eso, igual
en la p-gateway
es la parte que incluso vimos en el
en la configuración pasada
creamos el paquete
config, creamos esta clase
que nos pide, el security config
la anotamos con esto
con el enable web
security y el bin
este
y lo damos de alta
cuando esto sucede
este
cuando esto sucede
ya esta configurado lo que
explicamos, que todas las peticiones
ahorita nada mas protegí las rutas de
usuario
todas las rutas de usuario tienen que estar autenticada
todos los empujes que le pegues ahí
de lo contrario no se va a
construir la petición
entonces como yo probo esto
para eso preparamos
aquí
el mismo escenario
nosotros abrimos una
colección que se llama gateway
y en gateway tengo varios endpoints
si te fijas y probamos
cuando levantamos el puro gateway
probamos el de producto y este si te fijas no tiene autenticación
ahí sigue
funcionando, los voy a ir cerrando los que
los que ya no voy ocupando
estos de usuario que no entran por gateway
estos de ordenes que no entran por gateway
todo esto lo voy a ir dejando
aquí nada mas le voy a dar save
y listo
entonces todo esto lo voy a ir
minimizando porque ahorita ya no lo
ocupo
pero en la parte del gateway si te fijas
pasamos el de producto
no tiene mecanismo de autenticación
este va a responder sin problema
sin que yo le haga nada
simplemente estoy cambiando
que ahora entra en producto
por el puerto del gateway
ahora que va a pasar con los
de usuario
tu te fijas
ahorita voy a explicar mejor
esta petición de como se configura
el token
antes de eso en la presentación
si tu te fijas
aquí también te dan otros pasos
que básicamente son para ver que todo
en el reino
en keyclock este funcionando de forma correcta
este endpoint si
se me hace
valido probarlo entonces aquí también hay
una petición
que es el keyclock
tiene dos endpoints
el primero es para abrir la configuración
si yo lo ejecuto yo espero que me
responda y al momento de
responderme el 200
aquí yo veo todas las configuraciones que tienen mis reinos
va, entonces incluso de aquí
yo puedo obtener
el endpoint al cual yo
le tengo que pegar para ir
generando tokens, esta petición
es la que yo tengo en el metodo
de acá
este endpoint me sirve para que yo pueda
generar tokens
basados en ese reino
entonces yo hago ahorita la siguiente petición
que es un post y ahorita voy a ver
como se genera el token
de hecho es lo siguiente
yo obtengo el viewer token por medio
del endpoint al que
me dicta la configuración
le voy pasando estos
parámetros que son básicamente lo que yo
construí en mi cliente
en mi frase, todo esto ahí viene
en el json cliente que se asignó
el usuario y el password
que fuimos dando de alta
al hacer eso la petición
dándole
un endpoint, dándole
petición al token
yo solicitando ese token mejor dicho
nos va a devolver un token
de este estilo que es un jwt
un viewer token
entonces al hacer
eso si te fijas
entonces aquí yo ya puedo hacer la petición
mando los parámetros que me estaban pidiendo
que yo ya configure
y al hacer la petición
yo puedo ya generar un token
que de hecho el token ahí tiene
una expiración, un refresco
todo esto
lo que a mi me interesa es este el access token
entonces toda esta cadenota
yo me la tengo que copiar
y la voy a ocupar porque este es el mecanismo
que yo tengo que meter en el header
la autenticación
y así poder hacer la petición
antes de hacer este token
de mandar el token
yo voy a hacer entonces
la petición
desde el gateway al usuario
y yo lo voy a mandar
con un token que según yo
creé ayer y ya debería estar
caduco según lo entiendo
según espero, si, está caduco
entonces fíjate yo aquí mande incluso un token
como lo hago
simplemente me voy aquí al
pestaña de autorización
si te fijas es por gateway
a users porque te acuerdas
que configure para que todo lo que venga
desde user este protegido
entonces me va a pedir un token
yo aquí en autorización
gracias a posman puedo
de una forma fácil decirle
voy a agregar un token
y, ah perdón
y voy a, y aquí me pone
el campo para que yo rellené el token
que si te fijas es la cadena que
una cadena similar a la que me generó ahorita
el endpoint
cuando yo lo mando
me dice 401 un
autorizer y eso se debía que este
token ya expiró
es porque lo creé desde ayer
que pasa si yo incluso le digo que no
mandes el token
si yo le digo que no lo mande
ahí me sigue mandando un
autorizado, esto quiere decir
que está funcionando el mecanismo de
autenticación con keyclock
en ese caso
cuando yo mando, o caso contrario
cuando yo mando un token
fresco recién creado
desde que es el que
copia acá de este
endpoint que yo generé acá
cuando yo hago eso y lo mando
de forma correcta, aquí le doy
enviar y le doy save
ah bueno aquí responde error porque
no nos fijamos que mandamos el 4
pero si te fijas ya respondió
se intentó hacer la petición, fue errónea
porque mandó a traer un usfario que no existe
pero ya
pasó la autenticación
si yo mando ahora un 3 que es un usfario
que si existe aquí ya la petición
vuelve a funcionar
entonces con eso se está ilustrando
que el token
existe y funciona
si yo no lo mando otra vez
ahí me va a volver a tronar
me va a decir no, no estás autorizado
o sea todo está bien pero no estás
autorizado
entonces yo le mando
la petición nuevamente con el token
un token válido
y aquí está funcionando
va entonces ese es el mecanismo
de seguridad que se implementa
con la conexión
a KeyClock
va y bueno finalmente
en la presentación bueno
pues ahí acaba, ahí acaba la parte de
cómo se configura el
esta parte
no sé si haya alguna duda
alguna pregunta sobre cómo se
cómo funciona este mecanismo
de autenticación
alguna observación que tenga
si hay otros servidores incluso hay otros mecanismos
incluso este
por mecanismos me refiero a
utilizar por ejemplo
directamente la librería de
JWT
o sea JWT es
no es tanto una librería es más bien
un estándar que tú puedes ocupar
para este
hacer autenticación entonces
en este caso estos JWT
yo los hago
a través de este servidor porque
es digamos es más sencillo
dejar que los los administre
un endpoint
una configuración
a que yo implemente
literal una librería
esta es la librería por ejemplo así es
universal que nos va a permitir
generar tokens
tú puedes utilizar esto implementarlo con
su propio JDK
o su propia librería
y lo importa es que lo implementas directamente
en Spring
pero bueno yo
la idea es este aquí puedes
buscar la librería en el lenguaje que te
acomode y pues desde ahí lo vas
trabajando a mí
me acomoda bastante
utilizarlo con prefiero delegarle
ese trabajo al servidor
pero si te fijas aquí
soporte para Java
y bueno ahí podrías tú hacerlo
de forma más
artesanal o más manual
y bueno ahí seguramente también hay
otros servidores y nosotros nos podemos a
buscar otros servidores
proveedores de JWT de autenticación
similares aquí
y pues bueno los puedes
ocupar para que va
no obres a ti
algún otro comentario o alguna
duda fue claro o quieren que repasemos
este el flujo como se
configura como se crea todo
fue claro perfecto
ok va entonces
este
bien ahorita lo
lo repasamos entonces al momento de hacer
la práctica ahí que
quede de todos modos te digo la
si se fijan yo voy siguiendo lo que va en la
presentación entonces este
ee seguramente
ahorita vamos a terminar la
presentación nos va a llegar la hora
de comida y regresando
que ya seria
las ultimas dos horas la práctica
es volver a reconstruir todo esto
en sus ambientes
pero si se fijan ya es pura
configuración como lo hemos estado viendo
osea yo ya les voy a dar todo funcional ya van a tener
el user service
funcionando el product service funcionando
el order service y ya lo único que hay que hacer
es configurar los este
los demás este productos
entonces bueno
eso es lo que vamos a estar revisando
ahorita y
pues bueno entonces hay que apurarnos para la parte
de
del siguiente punto que creo que
ya es el ultimo que es la
el seguimiento de la
de los errores no
entonces con esta parte cerramos la
autenticación la seguridad con
entre el gateway y
y nuestro
servidor keyclock
y bueno
esto nos va a estar proporcionando los tokens y
la autenticación va seguridad
y bueno el ultimo punto es la parte
del seguimiento de microservicios
para el descubrimiento de
latencias ok
entonces en este en este ejemplo
o bueno en este punto
se está se propone utilizar
o bueno
se propone abordar la librería
Sleut
y nosotros tenemos como
propuesta también ocupar sitkin
que es un servidor en el cual
convive muy de la mano
con esta librería con
Sleut va
básicamente lo que hace Sleut
nosotros la configuramos es
que en todas las peticiones
que nosotros le podemos llamar traza
en toda la traza de la petición
te va a generar un identificador
un identificador mas o menos como
de este tipo no
una cadena alfanumerica
ese identificador
cuando ocurre un error
tu puedes copiarlo
y buscarlo directamente en sitkin
o viceversa lo puedes buscar en sitkin
encuentras el error
y lo puedes buscar en los logs
no reemplaza los logs simplemente es una forma
es una forma diferente otra alterna
de hacerlo
de buscar errores en
los logs entonces sitkin es
al igual que kicklock un servicio
aparte es un servidor que vamos a estar
instalando que ahorita vamos a ver
paso a paso configurando
también en las librerías
y con eso vamos a poder hacer la
la demostración va
entonces
el primer paso como ya lo hemos estado trabajando
vamos a agregar las
dependencias en todos los micros
servicios en donde queramos este
agregar este
seguimiento de errores o de latencias
aja entonces
las dependencias son estas
starter,slout y sitkin
va entonces yo lo puedo poner
por ejemplo en la parte de
productos
puedo buscar en el microservicio de productos
usuarios en el de
ordenes incluso creo que
también lo configuramos en el gateway
en todos esos microservicios
tu puedes buscar la librería slout
y la librería sitkin
entonces yo me voy a ir acá
a la de producto
y voy a ir cerrando otra vez todo esto
ah bueno
ahí le podemos
cierran las otras tabs
entonces aquí yo le doy en maven
si te fijas yo aquí encuentro las dos
dependencias y si te fijas ya estas son las últimas
entonces yo encuentro sitkin
y encuentro slout
yo teniendo esto ya lo
puedo instalar con maven
se descargan las dependencias
va
después en el application
y en el mail yo tengo que
configurar para que todas las
todas las
los identificadores
que se generen
entonces este
para que
se guarden aquí en la url
perdón
para que se configure con sitkin
sitkin es un producto aparte
que vamos a estar levantando
y se va a levantar en este puerto
localhost 94
ahorita vemos como se levanta
y básicamente le vamos a decir
con esta configuración a nuestros microservicios
que todo lo que venga
de slout lo meta
con una probabilidad de uno
esto quiere decir que en todas las
peticiones siempre esté generándome
esa traza
en todas las trazas siempre esté
aventando el identificador
para que no haya fallo
va entonces siempre voy a estar
agregando ese id con esa configuración
y luego
yo me voy aquí a la página
para ver como se instala sitkin
sitkin es no es más que un
proyecto es un producto
aparte
cuatro apián luego los comandos que
estoy en windows luego me cambio la maquina
un rollo pero a ver
déjame ver
y se copiaron los caracteres
ahí está entonces yo entro a sitkin
va y igual
yo voy leyendo ahí toda la documentación
se las dejo para que
para que las puedan ir viendo con
más detalle aquí está la
documentación y este
pues ahí te dice todo lo que sitkin puede hacer
incluso te grafica te hace varias
cosas ahí interesantes entonces
en el quick start nosotros
podemos ver este
como se instala por
medio de docker por medio de java
por medio de bueno del core
por medio de cualquier una de estos tres
metodos va yo en este caso elegí
para ya no usar tanto el docker
y variarle un poquito
estoy utilizando el core
con java para hacer eso
por ahí puse una nota en la presentación
que en un ambiente windows
podemos usar algún cliente bash
justo como el de
el de git el que tenemos
ahí también abierto entonces voy a
seguir las instrucciones y yo
haciendo ejecutando estos
dos comandos voy a poder
instalar este sitkin va
es el primer comando que
se ejecutaría es este core
yo al hacerlo
me va a empezar a bajar todas las dependencias
y al final me va a decir que puedo ejecutar
este comando para
lanzar la petición y entonces
este al momento de levantar eso
nos va a dar
ya la posibilidad de que yo
pueda entrar a través de esta dirección
a sitkin va
entonces vamos a ir haciéndolo
aquí en la presentación
me dice entonces que
yo puedo generar el comando
para este
este para levantar
el para descargar sitkin
va entonces hago el core
este
aquí si te fijas ya lo
ejecuto va y
cuando empiece a ejecutar te digo que esto
empieza a descargar un montón de paquetes
y cuando ya termina
te dice esta este mensajito
ahora puedes ejecutar este
comando que es el
mismo que te ponen acá
ya va ya sitkin punto ya
entonces ya lo ejecutas y al momento
de hacer esto te empieza a levantar la instancia
de sitkin y te dice que
está corriendo ya en el puerto 9411
va en localhost
9411
que de hecho es lo que te dice acá
cuando tu entras aquí también
te dice que aquí de hecho
sin importar como tu quieras
la configuración del idioma
yo aquí le puedo decir que se vaya
a
a
bueno cualquier idioma en este caso pues yo lo pongo en español
bueno creo que ahí se abrió algún micro
o quieren hacer alguna pregunta perdón
a si
este bueno o quienes lo manejamos
así al de hecho al revés pues nos vamos al
mandarín no
yo la verdad es que prefiero el español
entonces este
listo no
ahí tenemos el
la interfaz y
listo ahí yo puedo estar es que
buscando filtros puedo filtrar
y por nombre del servicio
por lo que tú quieras recuerda
que todos los servicios
que yo voy configurando
con las
instrucciones que me dicen acá
son todos los que va a
son todos los que si yo los
configuro todos aquellos que configure
todos los que le van a reportar a si
va con los que yo podría este
entrar
entonces si te fijas aquí yo tengo
varios filtros puedo
preguntarle por nombre de servicio aquí
tengo metidos
en estos tres en orden en producto
inusual
puedo hacer búsqueda de trazas
va o simplemente le puedo
decir aquí que corra todo y me va a estar
trayendo trazas yo aquí tengo ya porque son
ejemplos de
peticiones que ya hice incluso desde ayer
ya nada más fui reviviendo si se acuerdan
que hicimos ejemplos de
del error no cuando hicimos el usuario y demás
pues aquí como yo lo conecte pues ya lo
trazo pero vamos a hacer uno desde 0
para que se muestre
este que digo al final
se va a mapear de la misma forma
por ejemplo si nosotros
trajeramos el
identificador de usuario nada más que
según yo si lo va a reportar incluso
llegando desde el gateway si yo le
digo que me traiga el usuario 4 que
según yo no existía
ahí nos va a devolver un no autorizado
bueno pues este es otro error este
error no lo reporta porque esto no es
un error como tal aquí simplemente
el token este no está
funcionando lo que yo puedo hacer
más bien es en vez de pasarme por el
gateway aquí le voy a decir que no se guarde
le voy a decir
directamente al microservicio no le voy a pegar
vamos a darle
por ejemplo un get user
by ID y le voy
a poner el por ejemplo el 5
que es un usuario que no existe
y al momento
de hacerlo así ya me
está dando un ahora si este es un error
un 500 es un error
un internal server
que de hecho traigo otro ejemplo
también aquí mapeado
de hecho está en cualquiera de los tres
vamos a agarrar otra vez
el usuario por ejemplo
y cuando le haces una petición
no me acuerdo que en point en que en point lo puse
pues en el mismo de cuando tú haces un
by ID aquí tendríamos que detenerlo
y descomentar esta línea
y si nosotros hiciéramos ese ejemplo
cuando le pegaramos al
endpoint
de obtener los usuarios
por ID
si yo descomento esta línea pues obviamente
va a dar un problema de
división entre cero ya viste
puse ahí una línea que no la
detecte la compilación sino que
cuando esté corriendo va a mandar
ese exception cuando yo le pegue este endpoint
y esa traza también la va a reportar
va entonces podríamos también hacer
ese ejemplo parando el micro
comentando y descomentando esta línea
en este caso pues lo voy a dejar así con este
con este error de
no encontrar al usuario el
5 y tiene
escasos segundos que yo corrí esto
si yo le doy correr la traza
aquí te dice que bueno
tiene un minuto que lo corrió te dice
en donde se reportó en el micro
servicio de usuario te está diciendo
incluso yo le puedo decir a ver
dime que de que se trata y aquí
me está dando varias cosas
y este es el este es el
identificador que te digo que te devuelve
la librería de
si tú buscas esta
por ejemplo acá en los
en los usuarios
bueno yo aquí quité la
la de los
pero si yo aquí le doy buscar ahí
va a encontrar la traza y si tú te fijas
te va haciendo todo el seguimiento
te va diciendo desde que hiciste la petición
desde que se fue guardando
al al este
a la transacción y te está
mostrando cómo se fue a la base de datos o sea
te encuentra prácticamente ahí
te encuentra todo ahí son 45
registros que encuentra relacionadas
a la petición que tú
este que tú lanzaste
va entonces
esto esta es la traza que les
quería decir que encuentra
esta otra librería que se llama
a ver ahí dame una oportunidad
porque esto se vuelve loco
estoy haciendo
scroll pero ya sé
ya sé
ya sé controlas solo a ver nada más
déjamelo vuelvo a buscar
ahí está entonces
pues realmente la máquina
la puse con el tope de memoria
entonces este seguramente
se ocupa
varios pero bueno todo esto está como
diseñado para que
aguante estos procesos
el uso de
varios microservicios pues no
le van a representar bastante mucha carga
entonces
este
va entonces si te fijas
esa
identificador lo vamos siguiendo vamos
siguiendo ahí su historia
ahí te va diciendo cómo llega a la
base de datos a JPA y aquí
ya te va diciendo ya falló
la petición hasta que llega
entonces tú puedes ir siguiendo
la traza con ese
identificador y viceversa
imagínate que tú eres una persona que
está revisando los logs dame
chance es que aquí no sé por qué se va
el scroll
y se va además
pero lo que quería mostrarles
es esto si te fijas aquí te dice
cómo va a zipkin como reporta
te dice cómo lo está reportando con qué
traza tú puedes buscar
como te decía viceversa no puedes encontrar
esta traza
la puedes poner la puedes copiar de aquí
de tus logs y imagínate que quieres
más detalle porque dices no ahí si está
medio imposible te vas a zipkin
va y tú puedes hacer
una búsqueda por traza
es decir aquí le puedes decir
dame la ID de traza
yo lo copio y ahí también en automático
te lleva al problema donde
se generó aquí si te fijas
aquí podrías
ver la documentación de zipkin
y pues ir viendo qué hace más
con detalles todos los los la información
que aquí te pinta no pero aquí
creo que es bastante clara te estás diciendo
que fue una excepción de not
phone que de hecho es lo que hicimos
no hicimos buscar un usuario que no existe
en la base de datos nos manda
el status code error que son
500 que si te fijas es el mismo que
que reporta aquí posman no
500 entonces
esto es si quien va
te dice incluso en donde fue
un método del modelo dista controlador
en un control
te va diciendo todo esta parte no que
seguramente ya con más detalle
con más práctica pues la vas a poder este
entender de mejor forma
va pero entonces esto
es si quien no sé si queda
si quien combinado con la
traza de es leo
si queda alguna duda alguna pregunta
con con este componente
está bueno no
si si si está
está bueno
entonces este pues bueno
esa es la configuración creo que
no fue tan compleja tampoco
eso es más que nada ir
siguiendo ahí la la
presentación y tenerla
ahí la la paciencia
pero bueno entonces
pues con eso terminaría básicamente
todo el
el temario de lo que estaríamos este
eh
revisando si
después de esto hay otros dos
ejercicios que hay que hacer uno
es este
me piden hacer estas preguntas entonces tendríamos
que contestarlas ahorita se las voy
diciendo para que entre todos
votemos para ver cómo le hacemos
digo que la verdad me descontrola un poquito el tema
de la diferencia del horario
porque lo tenía mapeado
más como de 8 a
a 4 ahorita se
se me va un poquito y se me movió
entonces este generalmente
yo esto lo dejo al final
pero también tenemos que hacer
el tema de la práctica
también se viene la hora de la comida
y que más también se viene la evaluación
de ustedes hacia mí entonces
eh lo que podemos
hacer es
yo les iba a proponer si les parece
hacemos esto de lo que va
en la última media hora de aquí a las
dos eh
contestamos estas preguntas
las mandamos por correo
las ponemos aquí en el chat
y este
tomamos después de 2 a 3 horas de la comida
y en las últimas dos horas
que son de 3 a 5
nos ponemos a hacer esta práctica
la práctica básicamente es
levantar todo lo que tenemos acá
o sea vamos a bajar los repositorios
y les vamos a ir
configurando basándonos en las ramas
de develop va
entonces esa es la práctica nada más es
replicar todo para que
ustedes también lo tengan en su ambiente
y esa práctica pues ya
con esa práctica ya se van las dos
horas este que más
y ya al final
los últimos 5 minutos les paso el enlace
que es para que ustedes hagan la
evaluación hacia mí va
y digo eso es
es como lo último no?
esta evaluación es a retro
y este incluso
la pueden hacer terminando el
la llamada no? terminamos la llamada y ya
hacen la evaluación
como ven les parece el flujo que
que podemos seguir
si? perfecto
va no hay
alguna objeción nadie todos de acuerdo
listo bueno entonces
voy a dejar esta
pantalla
esta lamina a ver si se ve
según yo si se ve
son tres preguntas la verdad es que son
bastante sencillas creo yo
básicamente es definir que es
Spring Cloud sale
luego vamos a la pregunta
dos que es mencionar un componente
de Spring Cloud
que sea parte del temario
y otro que no
se acuerdan que vimos ahí
el día de ayer una página
en donde se veían varios este
varios componentes unos estaban
dentro del tema y otros no
básicamente de ahí podemos sacar la
respuesta y todo
está en la presentación de hecho
y el último punto que tal vez sería el más
este elaborado
hay que describir con nuestras propias palabras
el flujo de
Spring Cloud Bus
va con Kafka es decir
necesitamos entender como
es que Kafka funciona
como un bus y viene
a hacer la actualización
de variables desde
el config repo hasta el microservicio
en cuestión va
todo esto viene en las
presentación y es lo que hemos
estado revisando
cualquier duda que tengan la idea es
más bien que si existe preguntas
sobre esto pues lo podemos aclarar
si no queda claro algo lo
podamos volver a repasar
va como ven entonces
a la hora de descanso
no a la hora de la comida y ya nos
veríamos a las a las
tres
bueno quienes van acabando porfa lo
ponen ahí en el chat
dale men
dale dale no te preocupes
sin problema ahora
suerte hasta luego
dale entonces para todos los demás
no hay tema está clara la
actividad ¿quieren que repasemos algo?
o todo bien listo va entonces
voy a poner
mi micrófono y
este voy a estar aquí
al pendiente va
pongo mi y vuelvo a poner la
presentación
ah ok mira
lo que hay que hacer es
lo siguiente vamos a
en esta lámina que veo que
puse que es la de
las preguntas
tenemos que contestar estas tres
preguntas la forma de
ambientar todo esto que vimos
de Spring Cloud va
si es de hecho todo lo que hemos visto
todo lo vimos
en el curso viene aquí en la presentación
si alguien tiene alguna duda
sin problema lo podemos
repasar otra vez y
listo pero si
todo bien va
va que va perfecto
bueno no ahora si
que tu respondes a como las encuentras
a como te sientas
como era la
la práctica cuando hacías el examen
en la respondías
primero a las que te sentías
como con más confianza
y dejabas al último las más complejas
las más laboriosas
entonces no hay bronca tú respondes
como se te
como se te venga va
listo
pues ya varios han contestado
quedan todavía seis minutos
los que ya
contestaron ya sin problemas se pueden
ir a la
pues a la hora de la comida
sería de
de 2 a 3
va entonces nos volvemos a ver aquí a las 3
y continuamos con
lo de la práctica va y los que
faltan pues ahí todavía hay tiempo para
para mandar ahí las
las respuestas
alguien se le está complicando las
preguntas a nadie va que va
entonces voy a poner el
mute y nos vemos a las 3
va de 2 a 3
tomemos la hora y
nos volvemos a conectar aquí a las 3
perfecto provecho                

on 2023-08-31

language: ES

                  WEBVTT
Sí, exacto. Ahora se llevan los clientes.
Ahí sí le puedes dar en importar cliente y ahí sí va el Jason que acabamos de crear.
Y ahí sí te lo agarró, mira, porque ya te detectó todo. Ahí nada más darle agregar.
Sí, nada más el save y ya.
Ahí nada más hay que agregar el usuario.
Hay que irnos a la parte donde dice users.
Y ahí sí tienes que agregar el nuevo usuario.
Picar ahí a users, poner donde dice user.
En username ahí se queda igual en username.
Escribe porfa admin y donde dice ahí nada más te das agregar.
Y en la parte de donde dice credentials, ándale ahí, vuelvele a picar y ponle set password.
Y añadimos el admin.
Ajá, este.
No, de hecho hay que dejarlo así en apagado.
No, en apagado, exacto.
Bueno, es ahorita para que no te si lo apago ya se queda fija y si no va a expirar, como dice.
Y listo, ahora sí ya tienes los tres pasos.
Aja, el de sitkin.
Entonces sí, aquí anda.
Listo, pues prácticamente ya es la hora de salida.
Y en sí puedo levantar todos los micros.
Quién se crea si ya casi va por acá barrio que armando es uno.
Iváncro también.
Por ahí también vi que Jorge Ángel.
Levantó varias cosas.
Sí, esa igual.
Pues creo que todos, prácticamente avanzaron.
Tuvieron muy buen avance.
Pero no sé si alguien sí logró terminarlo todo así por completo el flujo.
Ah, sí.
Sí, probablemente esa cuando no te encuentras las librerías es porque.
Algo falta en las dependencias, entonces.
Igual y copiar, pegar así, tal cual.
El pump que está en el repositorio de product service en la rama de Velo.
Copiar, pegar y probablemente solo lo va a arreglar y bajar las dependencias.
Mira, de hecho, y me ven está pareciendo como que.
En modo refresca.
Entonces, bueno, ahí podríamos checar esa parte.
Y pues bueno.
Entonces la idea es que ahorita si pueden ir haciendo el commit.
A las ramas para que posteriormente cuando ustedes estén este.
En algún otro lado, pues puedan para les carga su ejercicio.
Lo bueno es que ya se familiarizaron con el ambiente.
Ustedes ven esto en mi rama de Débelo y ya lo pueden manipular sin problema.
Creo que esa es la idea principal para que ustedes lo puedan ocupar.
Si creen que algo les sirve, pues adelante.
El repo lo voy a dejar.
Yo creo que no solo los dejo una semana, entonces ahí sin problema.
Si la máquina la pagan, ustedes pueden descargarlo por completo y.
Y ahí este de la rama de Velo pueden bajar la.
Todo el proyecto va de los siete repos que ocupamos.
Entonces, bueno, ya para finalizar, les voy a pasar esta liga.
Les voy a pasar esta liga por chat.
Se les voy a poner aquí.
Y ahora es al revés.
Ahora es esta es una evaluación que es pedir una retro de.
De cómo fue el curso.
Y ahora es el reto.
Y ahora es el reto.
Y ahora es el reto.
Y ahora es el reto.
De cómo fue el curso.
Ahí este sí me hace un favor de llenarla.
Este probablemente en los en los dos minutos que quedan o si si quieren, pues ya lo llenan después.
Pero sí, sí, es bastante importante.
No sé si me pueden ayudar a dar ahí su su retro, sus comentarios de qué les pareció la la sesión.
Y pues listo, esto esto sería todo.
Ya es la hora de cerrar y pues ya.
Sin problemas.
Va así, claro.
Sí, bueno, nada más quitaba ahí como acentos raros y así, pero sí, sí, la mano realmente no tiene mucho.
Déjame lo voy guardando.
Y de una vez en la espacio.
Le voy a dar como PDF, descargar y.
Déjame ver en donde se guarda.
Dame.
A ver si me descarga esto.
Listo, ahí va.
Ya se descargó, creo.
Y entonces bueno, incluso tiene ahí un asterisco uno.
Ah, pero sabes que creo que lo hice mandándosela por correo a alguien verdad.
De quién fue el correo, se acuerdan?
Quién me lo pasó?
Email.
Andale, perfecto.
Presentación.
Y si me puedes ayudar, tú se las compartes a los demás compañeros.
Porfano a ver.
Entonces mira, es la que tiene un uno.
Es la más reciente.
Y voy a poner el clásico por informe.
Listo.
Sale.
Pues ahí está este.
No sé si hay algún otro comentario, alguna duda?
Pregunta antes de irnos.
Sí, sí, sí, sí.
Te da tiempo.
Hace el push.
Más que nada, subirlo es para que tú lo puedas retomar el día de mañana o cuando lo necesites.
De todos modos, el proyecto completo está en la rama de Débelo.
Ajá, no se ocupa como para evaluación y no, no, no, no.
No, es como para que ustedes lo tengan ahí.
Se lo lleve exacto para referencia suya y de todos modos el repo.
Sin sus ramas, el día de mañana pasa la semana y ya no están,
porque yo las ocupo para otros cursos.
Este se quedan las ramas de Débelo, no?
Por eso les mencionaba que pueden usarlas y sin problema.
Ese repo va a perdurar ahí un ratote.
Entonces, si su rama en una semana ya no está,
el repo en la rama de Débelo sí está y de ahí lo pueden ocupar.
Bien, entonces, Iván, vamos a ver hasta ti.
Vale, pues si no hay alguien más, ahí se pueden ir saliendo.
Ya no hay, ya no hay tema ahí con la sesión, va?
Voy a parar incluso y ya la grabó.                

on 2023-08-31