1:45:24
2023-08-31 09:10:16
49:05
2023-08-31 11:33:11
1:08:01
2023-08-31 12:36:28
42:18
2023-08-31 15:49:43
1:01:14
2023-08-31 23:21:25
5:58
2023-09-01 09:15:11
11:59
2023-09-01 09:21:33
3:42:30
2023-09-01 09:34:32
8:12
2023-09-01 16:29:10
Visit the Spring Cloud grupo 1 course recordings page
WEBVTT
-->
Armando, a César. Ángel ya
-->
está, sí. Buenos días. Perfecto.
-->
Adelante. No, si quieres comparte
-->
pantalla. Ahí se ve. Listo,
-->
recto. Entonces, se van a ir
-->
uniendo las demás personas. Ya
-->
podemos empezar o ¿Qué hacemos?
-->
Esperamos un ratito. Bueno,
-->
creo que se irán uniendo. A
-->
ver. Vuelvo a compartir
-->
pantalla. Listo. Ahí ya se ve mi
-->
pantalla, ¿Verdad? Perfecto.
-->
Bien. Entonces, este bueno, de
-->
hecho, antes de empezar, ya
-->
hicimos el paso uno, que es lo
-->
de la máquina. Eh, ahora, no
-->
sé si les voy a pedir un
-->
favor. El el curso está va a
-->
trabajar con la con la cámara
-->
apagada. Sí, pero ahorita
-->
nada más quisiera ver si nos
-->
pudiéramos este presentar de
-->
forma rápida, más que nada
-->
porque quisiera conocer respecto
-->
al tema de la de la audiencia,
-->
quién es, qué perfiles, qué
-->
perfiles tenemos, ¿No? Qué
-->
perfiles nos acompañan.
-->
Entonces, este yo me presento
-->
rápidamente, soy Diego Iván
-->
Valencia, estoy aquí con
-->
Noble Proj. El curso vamos a
-->
partir es el de Spring Cloud
-->
y pues bueno, yo, OK, sí, pues
-->
bueno, ahorita la idea es irnos
-->
presentando, entonces, en lo que
-->
hacemos un poco de tiempo y ya
-->
los demás se nos se nos irán
-->
uniendo, ¿Va? Entonces,
-->
continúo con con lo que soy,
-->
con lo que es mi mi
-->
presentación, soy Diego
-->
Valencia, les decía este y
-->
bueno, no no hay mucho que
-->
decir, yo yo también soy
-->
desarrollador, soy
-->
desarrollador full stack y
-->
pues bueno, ahorita voy a
-->
empezar compartiendo con ustedes
-->
este curso. Entonces, me
-->
gustaría si pudieran irme
-->
ayudando a presentarse, que
-->
quisiera saber qué rol juegan
-->
aquí en en AT&T, no sé si
-->
alguien quiera empezar. Adelante.
-->
Sí, Diego. Adelante Iván.
-->
OK. No, está bien, con que
-->
me digan qué, qué rol tienen
-->
aquí, qué, qué hacen.
-->
Perfecto. Y él quiere
-->
continuar. Venga.
-->
Ya una, discúlpame, caí de la
-->
llamada. Este listo. A ver,
-->
entonces, ¿Quién quién más
-->
quisiera continuar? Por
-->
favor, el ayudarnos a
-->
presentarse. Por ejemplo, nos
-->
falta Eveli. Adelante,
-->
adelante. Adelante.
-->
Perfecto. Perfecto. Otra vez
-->
más. Sale. Y creo que nos
-->
falta Eveli, ¿No?
-->
Perdón, estoy bien miedo. OK.
-->
No sé si faltó alguien más.
-->
Las personas que todavía no
-->
se conectan, pues yo creo
-->
que van a ir llegando, ¿No?
-->
Porque ya es nueve veintitrés
-->
y voy a empezar ya con con
-->
Eveli. Va. Sí, sí, sí.
-->
Perfecto. Bien, entonces.
-->
Entonces, este, OK. Voy a
-->
volver a compartir mi pantalla
-->
y por favor me avisan si la,
-->
si la pueden ver. Eso puede
-->
ver, ¿No? Ah, perfecto.
-->
Sale. OK. Entonces, bien.
-->
Esta es la presentación. La
-->
presentación la voy a
-->
trabajar, la vamos a
-->
trabajar, mejor dicho, de
-->
que tenga mejor control aquí
-->
sobre las diapositivas.
-->
Sale. En un momento
-->
también se las voy a hacer
-->
llegar. Me ha funcionado
-->
mandarlas por PDF. Bueno,
-->
más bien, eh, exportarla y
-->
compartirla. No, no, no
-->
pueden entrar al link. Pero
-->
bueno, no, no hay mayor
-->
problema. Como les decía,
-->
entonces, este, soy, digo,
-->
Valencia. Vengo de Noble
-->
Pro y vamos a impartir este
-->
curso de Spring Cloud. Eh,
-->
el curso en total son 14
-->
horas. Es decir, son dos
-->
días. Este, la duración por
-->
día, pues, es de siete horas
-->
y tenemos una hora de
-->
receso. Voy a admitir ahí a
-->
una persona. Listo. Tenemos
-->
una hora de receso. El
-->
horario, bueno, aquí el
-->
horario es diferente. El
-->
horario es de nueve a cinco.
-->
Va, pero bueno, al final
-->
siguen siendo las, las
-->
14 horas, siete horas por
-->
día. Vamos a tomar ahí nuestra
-->
hora de receso. Y les voy
-->
a ir explicando la metodología
-->
que vamos a ir ocupando para
-->
la impartición de, de este
-->
curso. Va. Entonces, eh,
-->
el temario que vamos a estar,
-->
el temario que vamos a estar
-->
revisando es, es este. Eh,
-->
no sé si se lo hicieron
-->
llegar, pero bueno, de todos
-->
más, aquí lo vamos
-->
repasando. Básicamente, el
-->
primer día es, a permítanme,
-->
voy a admitir a una persona.
-->
Básicamente, el primer día
-->
sí son, yo creo, la mitad es
-->
un poco teórico el curso. Ya
-->
la mitad del día ya
-->
entraremos a un tema más
-->
práctico. El día de
-->
mañana sí es más práctica
-->
que nada. Entonces, este,
-->
este es nuestro temario.
-->
Vamos a estar viendo lo que
-->
es la introducción a
-->
Spring Cloud, lo que es la
-->
arquitectura de los
-->
microservicios, lo que es
-->
el concepto de
-->
plataformas de
-->
servicios, el concepto del
-->
diseño nativo de nube.
-->
Vamos a estar viendo lo que
-->
es la descripción general de
-->
sus proyectos que contiene
-->
es la familia de
-->
Spring Cloud.
-->
Sí, vamos a estar viendo
-->
en específico estos
-->
subproductos que son el
-->
config server, el con su
-->
voz, el Eureka, el ribbon,
-->
el fame, his tricks.
-->
Vamos a estar viendo una
-->
descripción general de lo que
-->
es Spring Boot.
-->
Vamos a configurar nuestro
-->
entorno de desarrollo, que
-->
realmente eso, por eso es
-->
lo de la, la, las máquinas
-->
porque ya prácticamente ya
-->
está todo ambientado.
-->
Vamos a crear una aplicación
-->
pequeña de lo que es
-->
Spring Boot, como para ver
-->
una de las diferencias que
-->
tiene contra Spring
-->
Framework. Va.
-->
Y después ya, ya
-->
empezando en el tema 8 y
-->
el 9, tiene que ver
-->
todo lo que es con la familia
-->
de, de la iniciativa de
-->
Spring Cloud, de, de
-->
este framework.
-->
Vamos a estar haciendo
-->
gestión configuración
-->
centralizada y versionada
-->
con Spring Cloud Config
-->
y actualizaciones,
-->
actualizaciones de
-->
configuración dinámicas con
-->
Spring Cloud Boost.
-->
Esto lo vamos a estar
-->
viendo para el día de hoy.
-->
Este, como nos ha
-->
funcionado la metodología.
-->
Hoy vamos a terminar
-->
probablemente con estos
-->
siete puntos y todo lo que
-->
es de nube lo vamos a
-->
estar englobando el día de
-->
mañana para, para tomarlo
-->
todo desde, desde cero.
-->
Con respecto al día 2, vamos
-->
a estar haciendo descubrimiento
-->
de servicios con Eureka.
-->
Vamos a estar haciendo
-->
también lo que es equilibrio
-->
de carga con Ribon.
-->
Este es un concepto, es,
-->
es un tema más
-->
conceptual.
-->
No, no hay una práctica en sí
-->
que podamos probar ahorita
-->
porque, bueno, lo iremos
-->
mencionando en su momento,
-->
pero básicamente es por,
-->
necesitamos proveedores de
-->
nube para una infraestructura
-->
montada y todo esto, ¿no?
-->
Realmente ya era un poquito
-->
más elaborado.
-->
Vamos a trabajar con lo que
-->
es el concepto Lapi Gateway.
-->
Vamos a utilizar también
-->
clientes REST con la parte
-->
del frame client.
-->
Vamos a aplicar un,
-->
vamos a utilizar un concepto
-->
también que es, eh,
-->
sobre un patrón de diseño,
-->
de arquitectura que se llama
-->
Circuit Breaker.
-->
La, digamos, el
-->
subproducto de Spring Cloud
-->
que nos permite hacer eso
-->
es, eh, Histrix.
-->
Sí, aunque bueno, vamos
-->
a ver también a detalle que
-->
Histrix es una, libraría
-->
un poquito desactualizada.
-->
Vamos a utilizar otra,
-->
un poquito más moderna.
-->
Vamos a entrar también
-->
con la parte de asegurar
-->
los microservicios con
-->
Spring Security,
-->
Spring Cloud Security.
-->
Después vamos a utilizar
-->
también la parte de darle
-->
seguimiento al monitorio
-->
de microservicios para
-->
descubrir latencias
-->
y o problemas que puedan
-->
haber.
-->
Y finalmente, pues, vamos
-->
a dar observaciones finales
-->
sobre esta, este, estos
-->
dos días.
-->
Es un curso
-->
de bastante práctica.
-->
Entonces, vamos a estar ahí
-->
dando observaciones finales.
-->
Va.
-->
Hasta ahorita no sé,
-->
¿hay alguna duda o punto
-->
que quieran abordar con
-->
más detalles de los
-->
temarios?
-->
Perfecto.
-->
Va.
-->
Entonces, si no hay nada,
-->
continuamos ahora con
-->
el tema de
-->
la metodología, ¿sale?
-->
¿Cómo es que vamos a trabajar
-->
esta, este curso?
-->
Bueno.
-->
Entonces, vamos a estar
-->
utilizando
-->
una técnica que se llama
-->
la técnica Pomodoro.
-->
No sé si algunos de ustedes
-->
aquí presentes ya
-->
hayan escuchado o hayan
-->
incluso utilizado esta,
-->
esta técnica
-->
o la conozcan.
-->
Ah, perfecto.
-->
Muy bien.
-->
Salen.
-->
Entonces, la técnica Pomodoro
-->
no voy a entrar mucho
-->
como en detalles de,
-->
de
-->
muy, muy,
-->
muy técnicos, ¿no?
-->
Describir la detalle de,
-->
de qué es ni nada.
-->
Vamos a utilizar más bien ya
-->
el tema
-->
práctico
-->
para que se ocupa.
-->
Y básicamente es una
-->
técnica que nos promete
-->
o nos ayuda
-->
tener, sacar la máxima
-->
concentración
-->
para que
-->
este,
-->
nosotros podamos tener
-->
el mayor enfoque,
-->
el mayor enfoque.
-->
Entonces,
-->
con esta técnica
-->
vamos a, vamos a,
-->
o tratamos de
-->
garantizar que el,
-->
el tiempo que le
-->
invirtamos a esto
-->
porque la verdad son
-->
siete horas son pesadas,
-->
seguirlas, ¿no?
-->
De corrido.
-->
Esta técnica lo que nos
-->
permite es
-->
dividirlo en, en,
-->
en fases, por así decirlo,
-->
en donde se garantice,
-->
según estudios que,
-->
que tiene esta técnica,
-->
se garantice la máxima
-->
concentración,
-->
que son los primeros
-->
cuarenta y cinco minutos,
-->
¿va?
-->
Entonces, cada cuarenta
-->
y cinco minutos
-->
nosotros vamos a tener
-->
una sesión,
-->
vamos a decirlo intensa,
-->
de, de, de curso,
-->
¿no?
-->
Terminados esos
-->
cuarenta y cinco minutos,
-->
la técnica te dicta
-->
o la metodología
-->
te dicta que
-->
vas a dejar
-->
cinco minutos de descanso.
-->
Entonces, así lo vamos a estar
-->
llevando.
-->
Cada cuarenta y cinco minutos
-->
tomamos
-->
los cinco minutos.
-->
Yo voy a poner aquí
-->
mi, mi cronómetro
-->
en cuanto iniciemos,
-->
perdón,
-->
en cuanto iniciemos.
-->
Y esto lo vamos a estar
-->
haciendo por bloques,
-->
por cuatro bloques,
-->
¿no?
-->
En la iteraciones.
-->
En la cuarta
-->
iteración,
-->
vamos ya a aplicar
-->
un descanso
-->
un poco más largo,
-->
que son veinticinco minutos.
-->
Realmente en el curso,
-->
en el día,
-->
nada más se va a aplicar
-->
un descanso largo.
-->
Entonces, este,
-->
vamos a aplicar ese,
-->
ese descanso
-->
y después ya continuamos,
-->
¿no?
-->
Y el ciclo se,
-->
se sigue.
-->
No sé si
-->
hay alguna duda
-->
o pregunta de cómo
-->
vamos a estar haciendo esto
-->
o de la técnica
-->
más bien.
-->
Perfecto.
-->
Vale.
-->
Entonces, este,
-->
esto es lo que vamos a estar
-->
revisando.
-->
¿Va?
-->
Ahorita pongo yo
-->
el cronómetro
-->
y vamos a ir este,
-->
midiendo el,
-->
el pomodoro.
-->
Bueno, aquí tenía
-->
esta presentación.
-->
Yo creo que ya la voy a quitar.
-->
Esto, porque a veces
-->
los tiempos cambian, ¿no?
-->
Son dinámicos
-->
respecto a cuando
-->
entra la gente,
-->
todos completos
-->
respecto,
-->
por ejemplo,
-->
yo antes tomaba,
-->
daba el curso de ocho
-->
a cuatro,
-->
entonces ahora es de nueve.
-->
Entonces, aquí nada más
-->
la idea era
-->
ilustrar
-->
a qué hora,
-->
qué hora era, ¿no?
-->
Pero bueno,
-->
realmente ahorita ya
-->
estoy viendo que esta ya no,
-->
no está siendo
-->
tan,
-->
tan funcional.
-->
Vale.
-->
ya para ir empezando,
-->
voy a ir poniendo
-->
como primer
-->
tarea el pomodoro
-->
y son
-->
45 minutos
-->
a partir de ahorita.
-->
Listo.
-->
Dale.
-->
Entonces, ya está
-->
el problema.
-->
Bien, entonces,
-->
entonces,
-->
antes de empezar
-->
a ver todo el temario,
-->
usarlo
-->
parte por parte,
-->
voy a explicar
-->
o voy a tratar de,
-->
de, de mostrar
-->
el producto final
-->
a lo que vamos a,
-->
a llegar todos
-->
siguiendo este curso.
-->
Básicamente, este,
-->
lo que vamos
-->
a estar desarrollando
-->
en este,
-->
en este curso
-->
es un,
-->
es un sistema
-->
que nos va a permitir
-->
gestionar
-->
órdenes
-->
y productos.
-->
Nosotros vamos a tener
-->
tres entidades
-->
que son
-->
los usuarios,
-->
los productos,
-->
¿no?
-->
Y la relación entre
-->
usuario y producto
-->
genera una orden,
-->
¿va?
-->
Entonces,
-->
es tan sencillo,
-->
ese es el modelo,
-->
es muy, muy simple
-->
usuario,
-->
producto y orden,
-->
¿sí?
-->
Y de eso,
-->
y de esa relación,
-->
nosotros vamos a mapear
-->
todo lo que sea necesario
-->
para hacer
-->
gestión de,
-->
de órdenes,
-->
¿va?
-->
Eso es lo que vamos
-->
a estar creando
-->
y obviamente,
-->
pues vamos a estar
-->
utilizando la
-->
arquitectura de microservicios
-->
y todos los conceptos
-->
que nos dicta el temario
-->
de Spring Club.
-->
Vamos a hacer comunicación
-->
entre microservicios,
-->
vamos a,
-->
a medir latencias,
-->
vamos a configurarles
-->
un gateway,
-->
vamos a darles
-->
configuración
-->
distribuida con
-->
Config Server,
-->
entonces,
-->
vamos a estar aplicando
-->
todos los conceptos
-->
de Spring Cloud
-->
en este pequeño sistema,
-->
que realmente
-->
es muy,
-->
muy pequeño,
-->
¿va?
-->
No sé si hay
-->
alguna duda
-->
con respecto
-->
a lo que se va
-->
a desarrollar,
-->
si,
-->
si es un poco claro,
-->
quitando lo de
-->
Spring Cloud,
-->
si es claro lo que es
-->
el,
-->
la relación de estos,
-->
este,
-->
de este sistema,
-->
¿no?
-->
¿Sí?
-->
Perfecto.
-->
Listo.
-->
Bueno,
-->
si alguien tiene
-->
dudas de todo
-->
más lo vamos a ir viendo
-->
todo lo que va del,
-->
del curso
-->
y nos podemos ir
-->
para,
-->
si alguien tiene
-->
alguna pregunta,
-->
lo vamos a ir,
-->
a ir revisando,
-->
Todo esto lo vamos
-->
ir viendo poco a poco,
-->
¿va?
-->
Entonces,
-->
aquí damos un poquito
-->
más de detalle,
-->
el sistema va a estar
-->
compuesto por estos
-->
microservicios,
-->
vamos a tener
-->
un API Gateway,
-->
que es el,
-->
va a ser nuestro punto
-->
de entrada
-->
de todas las
-->
las solicitudes
-->
o las peticiones
-->
que hagan
-->
los,
-->
los usuarios,
-->
los clientes,
-->
¿va?
-->
Se va a encargar de
-->
pedir la autenticación,
-->
la autorización
-->
y de enrutar
-->
las solicitudes
-->
a los microservicios
-->
correspondientes.
-->
Eso es lo que
-->
hace un Gateway.
-->
Vamos a estar viendo
-->
nuestro microservicio
-->
de productos,
-->
que básicamente
-->
aquí es un
-->
CRUD
-->
sobre la entidad
-->
de productos,
-->
¿va?
-->
Vamos a estar haciendo
-->
alta,
-->
baja,
-->
modificación,
-->
consulta de
-->
productos.
-->
Vamos a tener
-->
también
-->
lo mismo,
-->
pero con
-->
la entidad de
-->
usuarios,
-->
vamos a estar haciendo
-->
este
-->
alta de
-->
usuarios,
-->
baja,
-->
modificación,
-->
consulta.
-->
Y lo mismo
-->
para las órdenes.
-->
Vamos a estar
-->
haciendo ahí
-->
también su CRUD,
-->
CRUD de órdenes.
-->
¿Sale?
-->
Y bueno,
-->
los componentes
-->
de Spring Cloud
-->
que vamos a estar
-->
utilizando,
-->
como les decía,
-->
son los que vienen
-->
básicamente en el
-->
temario.
-->
Vamos a estar revisando
-->
lo que es
-->
el
-->
Config Server,
-->
que nos va
-->
a ayudar
-->
a hacerle
-->
configuración centralizada
-->
a cada uno
-->
de los microservicios
-->
que se
-->
conecten a ese
-->
Config Server.
-->
Vamos a estar haciendo
-->
descubrimiento
-->
de servicios
-->
con Eureka,
-->
¿sí?
-->
Vamos a estar
-->
haciendo
-->
balanceo de carga
-->
con Ribon,
-->
que bueno,
-->
aquí es más que nada,
-->
como les decía,
-->
una parte
-->
muy conceptual,
-->
explicar ahí
-->
cómo lo
-->
maneja.
-->
Vamos a
-->
estar utilizando
-->
el Faint Client
-->
para hacer
-->
comunicación
-->
entre los tres microservicios
-->
que tenemos
-->
de cliente,
-->
producto y órden.
-->
Vamos a estar
-->
haciendo ahí
-->
comunicación
-->
entre ellos
-->
por medio
-->
de los clientes
-->
de Faint.
-->
Y vamos a
-->
aplicar el
-->
Patron
-->
Circuit Breaker
-->
para que cuando
-->
llegue a
-->
fallar
-->
alguna de estas
-->
comunicaciones
-->
entre ellos,
-->
el sistema
-->
no se
-->
quiebre,
-->
sino que tenga
-->
tolerancia a fallo
-->
y se evite
-->
esa
-->
propagación
-->
del error.
-->
Vamos a
-->
rescatarlo
-->
ahí con el
-->
Circuit Breaker.
-->
Y bueno,
-->
eso es lo que
-->
vamos a
-->
aplicar.
-->
Y finalmente
-->
también vamos a
-->
estar ocupando
-->
la parte de
-->
Cloud Security
-->
para el tema
-->
de seguridad
-->
y autenticación.
-->
Es decir,
-->
que vamos
-->
a aplicarle
-->
ese mecanismo
-->
de seguridad,
-->
de autenticación,
-->
para que
-->
desde el
-->
Gateway
-->
al inicio
-->
la petición
-->
sea validada
-->
con Security
-->
y en caso
-->
de que sea
-->
una
-->
petición
-->
válida,
-->
pues te deje
-->
continuar el flujo.
-->
Esto es básicamente
-->
lo que vamos a estar
-->
revisando
-->
en estos dos días.
-->
Obviamente,
-->
pues primero
-->
vamos a estar viendo
-->
la parte teórica
-->
de todos
-->
los componentes.
-->
Y ya mañana
-->
vamos a estar
-->
aplicando todo esto,
-->
pero ya a un nivel
-->
más práctico.
-->
Hoy nos vamos a
-->
quedar hasta la
-->
creación de los
-->
CRUTS,
-->
de los CRUTS
-->
de los tres
-->
de las tres
-->
entidades
-->
utilizando
-->
el concepto
-->
del framework
-->
de Spring Boot.
-->
Aquí hay
-->
un pequeño
-->
diagrama
-->
de arquitectura
-->
de cómo
-->
está funcionando
-->
la
-->
la nube
-->
de microservicios
-->
que estamos
-->
creando,
-->
que vamos a estar
-->
creando.
-->
Y básicamente
-->
es lo que les
-->
comentaba.
-->
Un cliente
-->
hace una
-->
petición
-->
y un Gateway
-->
es quien
-->
la va a
-->
recibir.
-->
Sale.
-->
Este Gateway
-->
le va a pedir
-->
la autenticación,
-->
va a pedir,
-->
va a solicitarle
-->
a Spring Cloud Server
-->
si es
-->
una
-->
petición
-->
válida.
-->
En caso de que
-->
eso sí
-->
sea correcto,
-->
vamos a
-->
continuar con
-->
el
-->
descubrimiento de
-->
servicios para
-->
saber a dónde
-->
está llegando
-->
realmente la
-->
petición.
-->
Una vez que
-->
tú ya
-->
tengas eso,
-->
vas a hacer
-->
ya la
-->
petición a cualquiera
-->
de los
-->
microservicios
-->
que estamos
-->
hablando,
-->
que les decía
-->
que es
-->
usuario,
-->
el de
-->
órdenes
-->
o de
-->
producto,
-->
es decir,
-->
tu cliente
-->
quiso crear
-->
un usuario,
-->
quiso hacer
-->
un producto
-->
o pidió
-->
una orden
-->
de algún
-->
producto para
-->
tal usuario.
-->
Esto es como
-->
lo vamos
-->
a reflejar.
-->
Cada
-->
microservicio
-->
va a tener
-->
una base
-->
de datos
-->
independiente
-->
y va a
-->
tener
-->
aplicado
-->
el patrón
-->
del Circuit
-->
Breaker
-->
por aquello
-->
de la
-->
tolerancia
-->
a fallos.
-->
Entonces,
-->
este
-->
diagrama es
-->
pequeño,
-->
pero bueno,
-->
a fines
-->
prácticos,
-->
ilustra
-->
el camino
-->
que va a seguir
-->
una petición,
-->
ya sea que se vaya
-->
a cualquiera
-->
de los tres
-->
microservicios
-->
que se van a
-->
crear.
-->
Esto igual
-->
lo vamos a estar
-->
explicando
-->
con más detalle
-->
y al
-->
compartirles
-->
la presentación,
-->
después
-->
lo van a
-->
poder ir
-->
repasando.
-->
¿Va?
-->
Bien.
-->
Entonces,
-->
ahora sí,
-->
empezaríamos
-->
con el primer
-->
este
-->
primer
-->
tema,
-->
que es la
-->
introducción
-->
de lo que es
-->
este
-->
Spring Cloud.
-->
¿Sale?
-->
Nada
-->
más quería
-->
partir antes.
-->
Todos los que me
-->
dijeron que eran
-->
devs,
-->
que creo que somos
-->
la mayoría,
-->
ustedes
-->
hacen aplicaciones
-->
con Java
-->
y conocen
-->
el framework
-->
de...
-->
O sea,
-->
no les suena
-->
raro cuando
-->
hablo de Spring
-->
framework
-->
o de Spring Boot
-->
o alguien
-->
no lo
-->
conoce,
-->
no lo maneja.
-->
Perfecto.
-->
Perfecto.
-->
¿Alguien más
-->
quiere
-->
compartir
-->
su opinión?
-->
Ah, perfecto.
-->
Ah, super.
-->
Ok.
-->
Ah, perfecto.
-->
Perfecto.
-->
Qué bueno que
-->
van saliendo
-->
esos conceptos
-->
porque
-->
justo
-->
el temario
-->
pues al hablar
-->
de microservicios
-->
vamos a estar
-->
hablando también
-->
de la
-->
otra
-->
contraposición,
-->
que son
-->
las aplicaciones
-->
monolíticas,
-->
que es como
-->
me comentan
-->
que se están
-->
manejando
-->
y vamos a ir viendo
-->
cómo viene
-->
esa...
-->
A partir de esa
-->
diferencia,
-->
Perfecto.
-->
Muchas gracias.
-->
Me imagino entonces
-->
que todo el mundo
-->
o la mayoría
-->
conocemos esta
-->
aplicación
-->
de Spring Cloud,
-->
digo de Spring Boot
-->
o de Spring Framework
-->
incluso,
-->
¿no?
-->
Sale.
-->
Entonces,
-->
Spring Cloud
-->
es lo mismo,
-->
es una plataforma
-->
que se construye
-->
sobre el framework
-->
de Spring
-->
y nos sirve
-->
para desarrollar
-->
aplicaciones
-->
que están basadas
-->
en microservicios.
-->
Nos proporcionan
-->
una serie
-->
de características
-->
que facilitan
-->
la construcción
-->
de este tipo
-->
de aplicaciones
-->
como
-->
el descubrimiento
-->
y registro
-->
de servicios
-->
con Neureka,
-->
balanceo de carga
-->
con Ribbon,
-->
comunicación
-->
entre microservicios
-->
con Faint,
-->
tolerancia
-->
a fallos
-->
con Hystrix
-->
y también incluye
-->
la parte de
-->
Spring Cloud Config
-->
que nos permite
-->
gestionar
-->
la configuración
-->
centralizada
-->
de los microservicios
-->
y aplicar cambios
-->
en tiempos de ejecución
-->
sin necesidad
-->
de reiniciarlos.
-->
Todos estos son conceptos
-->
que probablemente
-->
ahorita suenan
-->
muy
-->
muy burdos,
-->
¿no?
-->
Pero los vamos a ir
-->
detallando todos
-->
y cada uno
-->
por partes,
-->
¿va?
-->
Vamos a estar viendo
-->
lo que es
-->
Eureka
-->
y para qué nos sirve.
-->
Vamos a estar viendo
-->
para qué nos sirve Ribbon
-->
y balanceo de carga
-->
que básicamente
-->
estos dos proyectos
-->
van de la mano.
-->
Vamos a estar viendo
-->
para qué se ocupa
-->
un Faint Client,
-->
¿sí?
-->
Vamos a estar viendo
-->
también para qué se ocupa
-->
la tolerancia a fallos
-->
con el patrón
-->
Circuit Breaker
-->
y vamos a estar viendo
-->
también el tema
-->
de la configuración
-->
distribuida
-->
hacia los tres microservicios,
-->
bueno hacia todos
-->
los microservicios
-->
que vayamos a crear.
-->
Todo esto obviamente
-->
en una arquitectura
-->
como lo hemos estado
-->
diciendo,
-->
basada en microservicios,
-->
¿va?
-->
Vamos a ver
-->
cómo se crean
-->
estos microservicios
-->
y cómo operan
-->
entre sí,
-->
¿vale?
-->
Bien,
-->
entonces
-->
arquitectura
-->
de microservicios,
-->
Platform as a Services
-->
y diseño nativo
-->
de la Nublist.
-->
Entonces,
-->
arquitectura
-->
de microservicios
-->
es un enfoque
-->
de diseño
-->
de software
-->
con el que una aplicación
-->
se divide
-->
en pequeños componentes
-->
independientes
-->
conocidos como
-->
microservicios.
-->
Cada microservicio
-->
se enfoca
-->
en una tarea
-->
específica
-->
y se comunica
-->
con otras
-->
a través de protocolos
-->
ligeros,
-->
generalmente
-->
HTTP
-->
o mensajería.
-->
En contraste
-->
con las arquitecturas
-->
monolíticas
-->
donde toda la aplicación
-->
está contenida
-->
en un único código base,
-->
los microservicios
-->
permiten un desarrollo
-->
más ágil
-->
y una mejor escalabilidad.
-->
Cada microservicio
-->
puede ser desarrollado,
-->
implementado
-->
y escalado
-->
de forma independiente
-->
lo que facilitan
-->
la evolución
-->
y el mantenimiento
-->
del sistema en el tiempo.
-->
básicamente
-->
un microservicio
-->
es un
-->
es un proyecto
-->
que tú
-->
creas desde
-->
Spring,
-->
de Spring Boot,
-->
cualquiera de los dos frameworks
-->
nos permite
-->
o nos ayuda
-->
a crear microservicios.
-->
La iniciativa,
-->
digamos, la familia
-->
de Spring
-->
que se subderiva
-->
cuando tú quieres
-->
trabajar con microservicios
-->
es Spring Cloud,
-->
que básicamente
-->
tiene
-->
productos
-->
que son muy
-->
en específicos
-->
para este tipo
-->
de arquitecturas.
-->
Un microservicio
-->
pues como dices
-->
aquí
-->
en la diapositiva
-->
se va a comunicar
-->
con otros
-->
porque esa es la idea
-->
que se pueden comunicar
-->
a través
-->
de protocolos
-->
como
-->
HTTPS
-->
lo vamos a poder
-->
equiparar
-->
a lo que es
-->
el concepto
-->
de una API,
-->
de un rest API.
-->
Básicamente
-->
un microservicio
-->
va a exponer
-->
también
-->
servicios
-->
y
-->
por medio de
-->
HTTP
-->
nos vamos a poder
-->
consumir dentro de otros.
-->
Esa llamada
-->
generalmente
-->
nos vamos a ir
-->
adelantando un poquito
-->
de esas
-->
peticiones
-->
que
-->
o de esos
-->
servicios
-->
que se exponen
-->
nos podemos consumir
-->
dentro de otro
-->
por medio de
-->
un fame client
-->
por ejemplo.
-->
Los microservicios
-->
pues también
-->
se pueden seguir
-->
trabajando
-->
de alguna forma
-->
tradicional,
-->
es decir,
-->
empacándolos,
-->
generando un YAR
-->
o un WAR
-->
y
-->
de esa forma
-->
también lo puedes importar
-->
en otro proyecto
-->
de microservicio
-->
y también ahí
-->
estarías haciendo esa comunicación.
-->
Sin embargo
-->
la idea
-->
más común
-->
es
-->
exponerlos
-->
y llamarlos
-->
a través de este tipo
-->
de protocolos.
-->
¿Por qué?
-->
Porque bueno,
-->
cuando tú lo empaquetas
-->
empaquetas un microservicio
-->
dentro de otro
-->
pues ya rompes
-->
el principio
-->
de que sean independientes.
-->
Ahí ya
-->
se harían
-->
servicios dependientes
-->
porque dependen
-->
de una librería
-->
como si dependiera
-->
de una librería.
-->
Entonces ahí ya
-->
el concepto
-->
se rompe un poquito.
-->
Y bueno,
-->
también no podemos
-->
hablar de un microservicio
-->
sin hablar de una
-->
arquitectura monolítica
-->
que es más o menos
-->
lo que ahorita ya
-->
nos habían
-->
compartido
-->
de cómo se desarrollan
-->
ahorita las aplicaciones.
-->
A mí igual
-->
me tocó desarrollar
-->
aplicaciones en donde
-->
tienes un front,
-->
tienes un back,
-->
tienes la base de datos,
-->
todo aunque va
-->
distribuido en capas,
-->
aunque lo vas
-->
organizando de esa forma
-->
el proyecto,
-->
no deja de ser un monolito
-->
porque todo vive
-->
en un mismo servidor,
-->
en una única aplicación.
-->
Entonces
-->
pues de aquí se derivan
-->
adelante a César Augusto.
-->
Ahí vas a hablar, César.
-->
Es que se levantó tu mano.
-->
No te preocupes.
-->
Perfecto.
-->
Entonces
-->
bueno,
-->
les decía que
-->
estas arquitecturas
-->
que son monolíticas
-->
tienen
-->
o podemos hablar aquí
-->
y derivar
-->
ventajas y desventajas.
-->
Este
-->
una de las ventajas,
-->
por ejemplo, que tienen
-->
los microservicios
-->
es que
-->
son aplicaciones
-->
independientes.
-->
Tú puedes
-->
meterles
-->
digamos,
-->
todo el aprovisionamiento
-->
que una persona
-->
piensa
-->
cuando va a desarrollar
-->
una aplicación
-->
o una arquitectura.
-->
Ahorita pensemos
-->
de forma monolítico.
-->
Lo vamos a poder
-->
aplicar en cada uno
-->
de los microservicios.
-->
Vamos a poder pensar
-->
en estrategias
-->
de escalamiento,
-->
tanto horizontal
-->
como vertical.
-->
Vamos a poder pensar
-->
en que
-->
tenga una base de datos,
-->
probablemente incluso
-->
está distribuida.
-->
O sea,
-->
aplica lo mismo.
-->
El único,
-->
la única,
-->
una de las ventajas grandes
-->
es que
-->
cada microservicio
-->
se va a enfocar
-->
en una cierta actividad.
-->
Por ejemplo,
-->
y aquí yo pongo
-->
siempre este ejemplo.
-->
Imaginémonos
-->
que tenemos
-->
una arquitectura
-->
monolítica,
-->
una aplicación
-->
que se encarga
-->
de hacer
-->
enrolamiento de usuarios,
-->
que se encarga de...
-->
Ahí mismo,
-->
en la aplicación,
-->
el flujo
-->
envía correos,
-->
que además
-->
gestiona,
-->
no sé,
-->
tareas como de...
-->
Imaginémonos que es
-->
un comercio electrónico.
-->
También puedes gestionar
-->
productos,
-->
ventas,
-->
todo esto.
-->
Entonces,
-->
la idea de hacer
-->
un microservicio
-->
o un arquitecto
-->
a usar en microservicios
-->
es
-->
partir esta arquitectura
-->
que tenemos de forma monolítica.
-->
Y vamos a tener,
-->
por ejemplo,
-->
un microservicio
-->
que se encargue de hacer
-->
el login.
-->
Vamos a tener
-->
otro microservicio
-->
que se encargue
-->
exclusivamente
-->
de hacer las comunicaciones,
-->
¿no?
-->
Que envíe push notificaciones,
-->
que envíe
-->
correos electrónicos,
-->
mensajes.
-->
Vamos a tener
-->
otro microservicio
-->
que se encargue
-->
de procesar las ventas
-->
y otros microservicios
-->
que se encargue
-->
de hacer los crowds
-->
sobre cada producto,
-->
¿no?
-->
¿Cuál es la idea de esto?
-->
¿Cuál es la ventaja de esto?
-->
Que los roles
-->
que tú vas a contratar,
-->
por ejemplo,
-->
en tu empresa,
-->
ya son más en específicos
-->
que se dediquen,
-->
o sea,
-->
ya no te dedicas
-->
a contratar un full stack
-->
y conoce
-->
de todo,
-->
no porque no sea necesario.
-->
Obviamente,
-->
un microservicio
-->
también puede entrar
-->
un role full stack,
-->
sino porque
-->
el trabajo se va
-->
separando
-->
y se va segregando
-->
y las responsabilidades
-->
se van compartiendo
-->
y es más fácil
-->
que una persona
-->
pueda dedicar
-->
con toda su capacidad
-->
un solo producto
-->
a que puedas
-->
meterte
-->
en varias cosas
-->
de la arquitectura, ¿no?
-->
Que, además,
-->
no quita que
-->
una persona
-->
pueda ir conociendo
-->
otros microservicios, ¿no?
-->
Y, de hecho,
-->
eso es de las cosas
-->
que empiezan a hacer
-->
también desventajas.
-->
¿Por qué?
-->
Porque así como hablamos
-->
de esas ventajas,
-->
una de las desventajas
-->
también,
-->
si lo ven
-->
de la misma forma
-->
que yo,
-->
al momento de tener
-->
un montón
-->
de microservicios
-->
o de pequeños proyectos,
-->
la cosa también
-->
se empieza a complicar
-->
porque
-->
la tensión
-->
que tú le ponías
-->
a un solo producto,
-->
ahora se la pones
-->
a 15 productos, ¿no?
-->
Si uno
-->
de tus microservicios falla,
-->
es verdad que
-->
tu aplicación
-->
no se detiene
-->
a diferencia
-->
de una aplicación monolítica.
-->
Ahí también
-->
es otra ventaja
-->
de los microservicios.
-->
Pero una de las desventajas
-->
más grandes
-->
es precisamente,
-->
imagínate el tema
-->
de hacer documentación
-->
para
-->
un producto
-->
contra 15 productos, ¿no?
-->
Entonces,
-->
si es muy complejo
-->
estar haciendo documentación.
-->
Si es más complejo
-->
estar
-->
instalando
-->
o aprovisionando
-->
y cuidando
-->
que
-->
cada uno
-->
de esos microservicios
-->
monitoreándolos,
-->
que monitorear
-->
solamente
-->
a un aplicativo, ¿no?
-->
Entonces, va a tener
-->
ventajas, desventajas,
-->
dependiendo
-->
de lo que
-->
la empresa
-->
esté buscando, ¿no?
-->
Pero bueno,
-->
la arquitectura
-->
de microservicios
-->
al día de hoy
-->
es este,
-->
es un patrón
-->
bastante útil,
-->
muy utilizado
-->
en la industria actual.
-->
Y pues bueno,
-->
es la idea
-->
de este taller,
-->
de este curso,
-->
es conocer
-->
cómo se crea
-->
y este,
-->
pues bueno,
-->
estar hablando también
-->
de este tipo de
-->
ventajas, desventajas,
-->
¿va?
-->
No sé si tengan alguna duda
-->
sobre lo que es
-->
el concepto del microservicio
-->
contra las arquitecturas monolíticas.
-->
Y si quedó
-->
clara la
-->
la explicación,
-->
¿no hay alguna duda?
-->
¿Alguna pregunta?
-->
Perfecto.
-->
Va que va.
-->
En cualquier momento,
-->
me pueden decir
-->
que nos detengamos
-->
y nos volvamos a repasar,
-->
¿vale?
-->
Bien, entonces,
-->
un diagrama,
-->
por así decirlo,
-->
se puede ver
-->
de esta forma
-->
de lo que son las
-->
aplicaciones monolíticas
-->
que hemos estado
-->
revisando
-->
y lo que son los microservicios,
-->
¿no?
-->
Del lado izquierdo
-->
vemos una aplicación monolítica
-->
en donde
-->
está,
-->
todo está contenido
-->
dentro de una cajita,
-->
¿va?
-->
Y si tú te fijas,
-->
aquí tienes la
-->
interfaz de usuario,
-->
¿no hay un momento?
-->
Ah, ya.
-->
Tienes la interfaz de usuario,
-->
también tienes
-->
este,
-->
por ejemplo,
-->
la capa de
-->
lógica de negocios,
-->
tienes la capa
-->
de acceso a datos,
-->
lo que decíamos,
-->
Aunque nosotros
-->
podemos tener
-->
una aplicación monolítica
-->
separada en capas
-->
y perfectamente bien
-->
identificadas,
-->
no deja de ser
-->
un monolito
-->
que viene todo contenido
-->
dentro de un solo
-->
aplicativo, ¿no?
-->
Si se te cae,
-->
por ejemplo,
-->
una regla mal programada
-->
de
-->
lógica de negocios
-->
o por X o por Y,
-->
el
-->
programa agarró memoria
-->
de más
-->
o
-->
algo de ese estilo,
-->
pues,
-->
se quiebra y ya
-->
todo se quebró,
-->
¿no?
-->
La arquitectura de monolítica.
-->
Nos ha pasado muchas veces,
-->
Cuántas veces nos han subido
-->
a llamadas
-->
y a producción
-->
y hoy
-->
vamos a estar
-->
revisando aquí esto, ¿no?
-->
Y, bueno,
-->
en el tema de
-->
microservicios,
-->
si te fijas,
-->
esta misma
-->
arquitectura
-->
o esta misma
-->
aplicación
-->
se ve,
-->
pero en un concepto
-->
ya más separado,
-->
¿no?
-->
Tú tienes aquí
-->
la interfaz de usuario,
-->
que aquí a lo mejor
-->
hacemos un paréntesis
-->
porque
-->
el tema del microservicio
-->
se basa en dividirlo,
-->
¿no?
-->
En segregar
-->
las responsabilidades
-->
del
-->
aplicativo.
-->
Fíjate que la interfaz
-->
de usuario
-->
también puede ser
-->
algo que se le llama
-->
ya micro front-end,
-->
¿no?
-->
Es otro curso,
-->
es otra historia,
-->
pero también
-->
la misma interfaz
-->
de usuario
-->
también se puede ir separando
-->
como si
-->
de microservicios
-->
se tratara,
-->
¿no?
-->
Y, bueno,
-->
aquí en la parte
-->
de backend,
-->
pues puedes ver
-->
que hay un microservicio,
-->
hay otro microservicio,
-->
hay otro microservicio.
-->
Incluso aquí
-->
hay microservicios
-->
que están relacionados,
-->
que cada uno
-->
tiene su base de datos.
-->
Pues,
-->
imagínate que
-->
cae el microservicio
-->
que tenemos acá
-->
hasta el lado izquierdo,
-->
pues eso no va a dejar
-->
que siga operando,
-->
no le va a afectar
-->
tanto,
-->
que siga operando
-->
esta parte.
-->
Entonces,
-->
estas son de una
-->
de las ventajas
-->
que se pueden ver
-->
a simple vista
-->
de cuando tú hablas
-->
de aplicaciones monolíticas
-->
contra microservicios,
-->
Y de las desventajas,
-->
pues aquí también
-->
mismo lo ves, ¿no?
-->
Imagínate una persona
-->
entra,
-->
un onboarding
-->
de una empresa,
-->
o sea,
-->
soy nuevo,
-->
yo aquí en AT&T entro
-->
y me paso
-->
la documentación de esto,
-->
ah, pues,
-->
sin problemas,
-->
¿no?
-->
Lo puedo ir viendo,
-->
es más sencillo,
-->
todo se relaciona,
-->
pero me paso
-->
la documentación
-->
de cada microservicio,
-->
y pues hay
-->
que estar revisando
-->
qué equipo tiene
-->
el microservicio,
-->
quién es el encargado,
-->
y esto lo vemos
-->
a un nivel
-->
chiquito,
-->
porque estamos
-->
hablando de cuatro,
-->
pero realmente
-->
en las empresas
-->
hay empresas
-->
que tienen montones
-->
de microservicios,
-->
¿no?
-->
100 microservicios,
-->
200 microservicios,
-->
hay quienes
-->
tienen hasta más, ¿no?
-->
¿Por qué?
-->
Pues porque imagínate
-->
qué es separar esto,
-->
o sea,
-->
entonces,
-->
es,
-->
es muy grande,
-->
Realmente,
-->
ahorita lo vamos a ver,
-->
el ejercicio
-->
que nosotros tenemos
-->
mínimo son siete proyectos
-->
los que hay que levantar,
-->
entonces,
-->
eso también
-->
a mi punto de vista
-->
yo lo expongo,
-->
porque también son
-->
cosas que se deben de saber,
-->
¿no?
-->
De los microservicios,
-->
el ambientar
-->
un microservicio,
-->
que,
-->
que bueno,
-->
es más bien,
-->
ambientar un flujo,
-->
o sea,
-->
que tú quieras,
-->
por ejemplo,
-->
hacer un login
-->
y que mande
-->
el correo de confirmación
-->
de ese login,
-->
este,
-->
es levantar
-->
cuatro o cinco microservicios,
-->
¿no?
-->
Porque necesitas
-->
que haga esto,
-->
necesitas que haga esto,
-->
es ir siguiendo
-->
el flujo,
-->
también se vuelve un poquito
-->
más complicado,
-->
pero bueno,
-->
al momento que ya
-->
le vas agarrando la,
-->
la onda,
-->
pues ya,
-->
te subes al barco
-->
en los microservicios,
-->
y bueno,
-->
esto ya empieza a ser
-->
habitual de tu día a día,
-->
¿no?
-->
Va.
-->
Después,
-->
pues viene
-->
el tema de
-->
este enfoque,
-->
cuyas iniciales son
-->
PaaS,
-->
¿sí?
-->
De lo que es el
-->
Platform as Services.
-->
Básicamente,
-->
es un concepto
-->
que se refiere a
-->
una plataforma
-->
de desarrollo,
-->
a tener una plataforma
-->
de desarrollo
-->
y despliegue de aplicaciones,
-->
que nos va a proporcionar
-->
un conjunto de herramientas
-->
y servicios
-->
para facilitar
-->
la implementación
-->
y la gestión
-->
de aplicaciones
-->
en la nube.
-->
Platform as Services
-->
ofrece
-->
una abstracción
-->
de la infraestructura
-->
subyacente,
-->
lo que permite
-->
a los desarrolladores
-->
centrarse
-->
en la lógica de negocio
-->
en lugar de
-->
preocuparse
-->
por la configuración
-->
y el mantenimiento
-->
del entorno de ejecución.
-->
Entonces,
-->
de esta,
-->
de esta
-->
definición,
-->
que también suena
-->
un poco burda,
-->
yo creo que
-->
lo más importante
-->
es esto que está
-->
subrollado aquí
-->
en negritas,
-->
que básicamente
-->
Platform as Services,
-->
lo que nos permite hacer
-->
es esto,
-->
¿no?
-->
Centrarnos,
-->
y está muy enfocado,
-->
así,
-->
tal cual la palabra
-->
desarrollador,
-->
está muy enfocado
-->
hacia los desarrolladores,
-->
¿va?
-->
Y nos permite
-->
únicamente
-->
centrarnos
-->
en la lógica de negocio
-->
en vez de hacer configuraciones
-->
y mantenimientos
-->
del entorno.
-->
Esto quiere decir
-->
que
-->
tú cuando quieres hacer
-->
una,
-->
ah,
-->
un aplicativo,
-->
puedes
-->
contratar a un servidor.
-->
Todo esto
-->
del Platform as Services
-->
viene a
-->
nutrir más
-->
el concepto
-->
o se nutre
-->
el concepto
-->
de lo que es
-->
el Cloud Computing,
-->
¿no?
-->
El concepto
-->
de la nube.
-->
Cuando hablamos
-->
del concepto
-->
de la nube,
-->
luego,
-->
luego,
-->
viene a la cabeza
-->
el hecho
-->
de que tenemos
-->
probablemente uno
-->
o varios
-->
proveedores
-->
de nube,
-->
Conocemos,
-->
por ejemplo,
-->
conocemos
-->
a Amazon,
-->
¿no?
-->
Amazon Web Services,
-->
conocemos
-->
este Google,
-->
la plataforma
-->
de Google también
-->
ofrece
-->
servicios
-->
de computación
-->
en la nube.
-->
Conocemos
-->
también Azure.
-->
Conocemos
-->
un montón
-->
de aplicaciones,
-->
de proveedores,
-->
¿no?
-->
Que son
-->
proveedores de nube.
-->
Esos proveedores
-->
lo que hacen
-->
es dividir
-->
en capas,
-->
por así decirlo,
-->
los servicios que ofrecen.
-->
Dentro de una de las capas
-->
que tienen
-->
se habla
-->
del concepto
-->
del Platform as Services.
-->
Ahorita lo vamos a ver
-->
en una imagen
-->
que creo que es más
-->
en esta,
-->
que es más
-->
ilustrativa.
-->
Ellos
-->
hablan de este modelo
-->
de servicio
-->
en nube,
-->
¿no?
-->
Entonces,
-->
si te fijas
-->
aquí,
-->
el PASS
-->
o el Platform as Services
-->
dentro de esta pirámide
-->
que ahorita
-->
hay muchos más servicios,
-->
pero digamos
-->
los tres más
-->
importantes
-->
se pueden categorizar
-->
de esta forma,
-->
¿no?
-->
Tú tienes
-->
lo que es
-->
el concepto del IaaS
-->
o infraestructura
-->
as Services
-->
como
-->
capa base,
-->
¿no?
-->
Hasta bajito.
-->
Ahorita vemos que es
-->
este producto
-->
o subproductos
-->
que se pueden encontrar
-->
aquí.
-->
Después tienes
-->
el proyecto
-->
que estábamos hablando
-->
que es el Platform
-->
as Services
-->
o plataforma
-->
como servicio.
-->
Y al final
-->
en la
-->
en la punta
-->
hasta arriba
-->
tienes lo que es
-->
el software
-->
as Services.
-->
Si te fijas
-->
esta imagen
-->
del lado derecho
-->
tiene
-->
el tema
-->
de los roles
-->
a los que principalmente
-->
está dedicado
-->
a ese producto
-->
o esa gama de productos
-->
y de la izquierda
-->
tiene ciertos ejemplos,
-->
¿no?
-->
Por ejemplo,
-->
infraestructuras
-->
as Services
-->
está más dedicado
-->
a las personas
-->
que son
-->
arquitectos de red,
-->
administradores
-->
de tecnologías
-->
de información.
-->
Algunos ejemplos
-->
son
-->
justamente
-->
las mismas nubes,
-->
¿no?
-->
StackScale,
-->
Amazon Web Services,
-->
Azure,
-->
VMware.
-->
Son
-->
productos
-->
que ofrecen
-->
prácticamente todo
-->
para que tú te puedas
-->
servir
-->
y crear
-->
una arquitectura.
-->
Puedas
-->
instalar
-->
algún servidor,
-->
puedas
-->
aprovisionar
-->
mecanismos
-->
de
-->
escalabilidad,
-->
etcétera,
-->
etcétera.
-->
Lo que
-->
¿cómo se llaman estos
-->
mecanismos
-->
para hacer log,
-->
log sobre
-->
los
-->
los servicios
-->
que ocupes,
-->
monitoreo,
-->
¿no?
-->
Todo esto.
-->
Entonces,
-->
toda esta parte
-->
es como un
-->
nivel
-->
un poco
-->
para gente
-->
que se dedica
-->
más a la
-->
a la arquitectura,
-->
a la administración,
-->
gente de DevOps,
-->
por ejemplo,
-->
¿no?
-->
Los perfiles
-->
más modernos
-->
se encuentran
-->
en esta capa.
-->
En la capa
-->
de platformas
-->
a services
-->
se encuentra
-->
más orientada
-->
al tema
-->
a los que somos
-->
desarrolladores
-->
de software,
-->
¿no?
-->
Quienes a lo mejor
-->
tratamos
-->
en
-->
instalar un Apache,
-->
en configurarlo
-->
o algún
-->
producto nuevo
-->
de los que van
-->
saliendo,
-->
e
-->
instalarlo,
-->
configurarlo,
-->
a lo mejor
-->
nos cuesta un poquito
-->
más de trabajo.
-->
La nube dice,
-->
no te preocupes,
-->
yo te ofrezco
-->
ya servicios
-->
que no necesitan
-->
de eso porque
-->
ya está hecho,
-->
ellos lo mantienen,
-->
tú nada más
-->
dedícate a
-->
desarrollar,
-->
¿va?
-->
Entonces,
-->
aquí tú puedes utilizar
-->
productos como
-->
OpenShift,
-->
Heroku,
-->
Flynn,
-->
Cloud Foundry,
-->
¿no?
-->
Puedes ocupar
-->
cualquiera de esos
-->
y puedes estar
-->
así aprovisionando,
-->
ya el aprovisionamiento
-->
ya viene,
-->
tú ya nada más
-->
te dedicas a
-->
desarrollar.
-->
Aquí entra,
-->
por ejemplo,
-->
también
-->
a lo mejor suena
-->
un poco más
-->
el concepto
-->
de las Cloud Functions
-->
o de las Lambda Functions,
-->
Que tú ya nada más
-->
de
-->
le dices a Amazon
-->
que quieres crear
-->
una
-->
Lambda Function
-->
y te dice
-->
básicamente en qué
-->
lenguaje quieres
-->
y ya
-->
con eso tú
-->
empiezas a
-->
desarrollar,
-->
le da con un simple
-->
clic,
-->
haces el despliegue
-->
y ya
-->
tu aplicación,
-->
bueno,
-->
tu función,
-->
mejor dicho,
-->
ya está operando,
-->
¿no?
-->
Ya la puedes mandar a llamar
-->
desde
-->
la URL que te proporcionan
-->
y listo.
-->
Tú no te preocupaste
-->
por
-->
instalar algún
-->
servidor,
-->
configurarlo,
-->
desplegarlo,
-->
nada de eso.
-->
¿va?
-->
Y por último
-->
viene
-->
hasta
-->
arriba de la pirámide
-->
de
-->
Modelo de Servicio,
-->
viene
-->
lo que es
-->
este
-->
el software
-->
hasta services
-->
que
-->
básicamente
-->
como dice aquí
-->
en la derecha
-->
ya nuestros
-->
usuarios
-->
a quien está
-->
dedicado
-->
son los
-->
usuarios finales,
-->
¿no?
-->
Entonces,
-->
algunos ejemplos
-->
pues son
-->
Gmail,
-->
Trello,
-->
Slack,
-->
Office 365,
-->
todos
-->
estos
-->
productos
-->
que ya están
-->
desarrollados,
-->
que ya sirven
-->
para un
-->
cierto
-->
fin
-->
y cuyos usuarios
-->
finales
-->
son los que lo ocupan,
-->
por ejemplo,
-->
gente que
-->
ocupa
-->
el correo de
-->
Gmail
-->
o utiliza Slack
-->
para
-->
comunicaciones,
-->
esos software
-->
que existen
-->
en la nube,
-->
esos a lo que se refiere
-->
el software
-->
hasta services,
-->
¿va?
-->
Podemos ya ocupar
-->
ellos venden
-->
software como
-->
servicio,
-->
literal,
-->
es lo que quiere decir
-->
la palabra,
-->
¿no?
-->
En la capa de
-->
abajo ellos venden
-->
plataforma
-->
como servicio
-->
y en el de
-->
abajo ellos venden
-->
infraestructura
-->
como servicio,
-->
¿va?
-->
Eso es básicamente
-->
el modelo
-->
de servicio
-->
de la nube
-->
que es
-->
ofrecido
-->
pues por
-->
diferentes
-->
proveedores,
-->
¿va?
-->
No sé si hay
-->
alguna
-->
pregunta,
-->
alguna observación,
-->
comentario sobre
-->
este
-->
este concepto,
-->
listo,
-->
va,
-->
entonces si no hay
-->
nada
-->
podemos
-->
continuar
-->
y
-->
listo.
-->
Entonces,
-->
vamos a ver
-->
un pequeño
-->
ejemplo
-->
a nivel
-->
muy teórico
-->
de lo que es
-->
de lo que sería
-->
crear un micro
-->
servicio
-->
en una de estas
-->
plataformas
-->
que se llama
-->
Heroku
-->
que si se fijan
-->
Heroku está aquí
-->
en la
-->
en el segundo
-->
nivel
-->
como
-->
como
-->
plataformas
-->
a
-->
servicios,
-->
¿va?
-->
Entonces,
-->
literal,
-->
con estos
-->
seis pasos
-->
puedes crear
-->
un micro
-->
servicio,
-->
¿va?
-->
Entonces,
-->
aquí se está
-->
hablando de un micro
-->
servicio que se va a
-->
llamar
-->
user service
-->
que se va a encargar
-->
de gestionar
-->
usuarios de
-->
una aplicación,
-->
¿va?
-->
Se ocupa
-->
Heroku como
-->
proveedor
-->
de
-->
plataformas
-->
a
-->
servicios
-->
y
-->
los pasos
-->
para desplegar
-->
este micro
-->
servicio
-->
serían estos.
-->
Obviamente,
-->
tú tienes que
-->
tener una
-->
cuenta en
-->
Heroku,
-->
te registras,
-->
creas la
-->
cuenta,
-->
¿ja?
-->
Vas a
-->
instalar
-->
el CLI
-->
de
-->
Heroku,
-->
ahí en
-->
la página
-->
viene
-->
mucha
-->
documentación
-->
para hacer
-->
esta instalación.
-->
El
-->
CLI
-->
básicamente
-->
son las
-->
siglas de
-->
Command Line
-->
Interface,
-->
que básicamente es
-->
el hecho
-->
de que tú
-->
es una herramienta
-->
que tú desde
-->
tu línea de
-->
comandos,
-->
desde tu
-->
terminal,
-->
vas a
-->
poder manejar
-->
el cliente
-->
de la
-->
nube,
-->
de la instancia
-->
de la cuenta
-->
que tienes
-->
de Heroku,
-->
la vas a
-->
poder manejar
-->
desde la
-->
línea de
-->
comando
-->
y nos va a
-->
permitir interactuar
-->
con esa
-->
plataforma,
-->
¿no?
-->
Vas a
-->
configurar
-->
tu entorno
-->
local
-->
para que
-->
funcione
-->
en el entorno
-->
de Heroku,
-->
puede incluir
-->
ajustar
-->
variables de
-->
entorno,
-->
dependencias,
-->
configuraciones,
-->
todo esto
-->
viene en
-->
la plataforma
-->
para que tú
-->
puedas ir
-->
configurando
-->
lo que
-->
la línea de
-->
comandos,
-->
tú puedes
-->
crear la
-->
aplicación,
-->
hay un comando
-->
que te
-->
genera ya
-->
todo el
-->
te va a
-->
descargar
-->
todos los
-->
paquetes,
-->
todo lo que
-->
ocupes
-->
dependiendo
-->
del sabor
-->
que quieras
-->
ocuparlo,
-->
Java,
-->
Node,
-->
Python,
-->
algún
-->
lenguaje
-->
y te
-->
va a
-->
descargar
-->
todo el
-->
contenido
-->
de la
-->
aplicación,
-->
y va a
-->
existir un
-->
comando
-->
que te
-->
ayude a hacer
-->
el despliegue
-->
para que
-->
este ya
-->
esté disponible
-->
en
-->
Heroku
-->
y en
-->
automático
-->
te va a
-->
brindar
-->
lo que es
-->
la escalabilidad,
-->
lo que es la
-->
gestión
-->
del servicio.
-->
Según las
-->
necesidades
-->
de esta
-->
aplicación
-->
va a ir
-->
haciendo
-->
escalamiento
-->
y
-->
eso
-->
de que se
-->
vaya
-->
te vaya
-->
garantizando
-->
que haya
-->
suficiente
-->
instancias
-->
para que
-->
siempre
-->
esté disponible
-->
y se maneja
-->
la carga
-->
y tu
-->
aplicación siempre
-->
esté disponible,
-->
eso viene
-->
incluido,
-->
por eso es que
-->
esto es un
-->
platform
-->
de services
-->
porque tú no te
-->
vas a
-->
preocupar de
-->
nada de esto,
-->
tú de
-->
lo único que te
-->
enfocas es
-->
del
-->
desarrollo.
-->
Desarrollas
-->
eso,
-->
lo subes
-->
y pues bueno
-->
obviamente
-->
esto tiene
-->
tiene un
-->
este
-->
tiene un
-->
costo,
-->
quiere decir que
-->
tú le estás
-->
pagando a un
-->
proveedor
-->
para que ellos
-->
se encarguen
-->
de hacer todo esto
-->
y pues bueno,
-->
de eso
-->
te va a llegar
-->
cierta
-->
cierta
-->
factura,
-->
por hacerte
-->
esa
-->
labor.
-->
Listo,
-->
básicamente eso es
-->
como un
-->
nivel así
-->
muy teórico
-->
de cómo se
-->
podría crear
-->
un micro
-->
servicio,
-->
no era
-->
más que
-->
para
-->
decir que
-->
son ciertos
-->
pasos,
-->
no se
-->
necesita nada
-->
más.
-->
Y bueno,
-->
después
-->
entraríamos al
-->
concepto
-->
de el
-->
diseño
-->
nativo de la
-->
nube,
-->
que todo esto
-->
se viene
-->
a
-->
conjugar con lo que
-->
ya hemos
-->
estado
-->
hablando,
-->
del tema de
-->
los
-->
micro
-->
servicios,
-->
es una
-->
metodología
-->
de diseño
-->
de
-->
aplicaciones
-->
que se adapta a
-->
las
-->
características
-->
y capacidades
-->
de la
-->
nube,
-->
incluye
-->
la
-->
utilización
-->
de
-->
servicios
-->
gestionados,
-->
ofrecidos
-->
por proveedores
-->
la
-->
nube,
-->
como
-->
las
-->
bases
-->
de
-->
datos,
-->
los
-->
sistemas
-->
que
-->
te
-->
permiten
-->
hacer
-->
el
-->
encolamiento
-->
de
-->
mensajes,
-->
servicios
-->
de
-->
autenticación,
-->
y
-->
este
-->
diseño
-->
de
-->
la
-->
nube
-->
enfatiza
-->
la
-->
modularidad
-->
y
-->
la
-->
escalabilidad,
-->
obviamente
-->
porque
-->
al pensar
-->
en hacer
-->
micro
-->
servicios,
-->
estos
-->
son
-->
modulares,
-->
son
-->
escalables,
-->
son
-->
independientes,
-->
son
-->
unidades
-->
únicas,
-->
y
-->
eso
-->
permite que
-->
las
-->
aplicaciones
-->
se
-->
ejecuten en
-->
múltiples
-->
a
-->
lo
-->
momento de
-->
crear
-->
aplicaciones,
-->
te
-->
optes
-->
por ir
-->
por
-->
la
-->
metodología
-->
o
-->
la
-->
arquitectura,
-->
mejor dicho,
-->
de
-->
micro
-->
servicios,
-->
y
-->
en
-->
automático
-->
vas a
-->
poder
-->
proveer
-->
de
-->
todo
-->
eso a
-->
tus
-->
aplicaciones,
-->
vas a
-->
tener bases
-->
de datos
-->
que son
-->
independientes,
-->
vas a
-->
poder meterle
-->
sistemas
-->
de encogamiento
-->
de mensajes
-->
que se dediquen
-->
a gestionar,
-->
ya sea uno o
-->
varios
-->
micro
-->
servicios,
-->
vas a tener
-->
estos
-->
servicios
-->
de
-->
autenticación,
-->
es decir,
-->
nada de
-->
lo que
-->
no hemos
-->
trabajado
-->
con
-->
aplicaciones
-->
monolíticas,
-->
solo que
-->
esta vez
-->
tú puedes
-->
tener también
-->
la opción
-->
de
-->
hacerlo
-->
de la mano
-->
de algún
-->
proveedor
-->
de
-->
servicios
-->
de nube
-->
que
-->
nos va a
-->
permitir
-->
ya
-->
no
-->
tanto
-->
estar
-->
preocupados
-->
por
-->
toda esta
-->
parte,
-->
ya lo
-->
hace
-->
un
-->
platformas
-->
o
-->
services,
-->
o sea,
-->
tienes
-->
otro
-->
enfoque
-->
para
-->
el
-->
desarrollo
-->
de
-->
tu
-->
servicio
-->
o de
-->
tu
-->
aplicativo
-->
siguiendo
-->
este
-->
diseño
-->
nativo.
-->
Sale.
-->
Entonces,
-->
ya
-->
estaríamos
-->
entrando
-->
al siguiente
-->
tema,
-->
no sé si
-->
antes
-->
de eso
-->
hay
-->
alguna
-->
duda,
-->
comentario,
-->
algo que
-->
quieran
-->
repasar
-->
lo que
-->
es
-->
estos
-->
conceptos
-->
de
-->
la
-->
nube,
-->
microservicios,
-->
monolíticos,
-->
platformas
-->
a
-->
services,
-->
algún
-->
concepto
-->
que
-->
quieran
-->
que repasemos,
-->
algo que
-->
quieran
-->
comentar
-->
ustedes,
-->
listo.
-->
Va.
-->
Entonces,
-->
si no hay
-->
nada,
-->
continuamos.
-->
Si al inicio
-->
puede parecer un poquito
-->
tediosa
-->
la parte
-->
teórica,
-->
vamos viendo que
-->
si es,
-->
es necesaria,
-->
sobre todo,
-->
para entender los
-->
siguientes
-->
puntos.
-->
Y,
-->
ahora vamos a
-->
entrar un poquito
-->
en materia
-->
de lo que es
-->
este
-->
Spring Cloud,
-->
va.
-->
Entonces,
-->
nos habla
-->
en este punto
-->
el temario
-->
que
-->
demos una
-->
descripción
-->
general
-->
de lo que son
-->
los
-->
subproyectos
-->
de
-->
Spring Cloud.
-->
Para eso,
-->
yo aquí en la
-->
presentación
-->
puse este enlace,
-->
que nos lleva
-->
directamente
-->
a la
-->
documentación
-->
oficial
-->
de Spring Cloud.
-->
Y,
-->
si te fijas
-->
aquí,
-->
en Spring Cloud,
-->
en esta página
-->
que yo me imagino
-->
que todos
-->
conocemos,
-->
todos los que hemos trabajado
-->
con Spring,
-->
conocemos,
-->
vemos lo que son
-->
todos los productos
-->
que
-->
tú puedes
-->
ocupar en la
-->
familia de
-->
Spring.
-->
Aquí,
-->
si te fijas,
-->
está Spring Framework,
-->
aquí tú puedes ver
-->
lo que es
-->
Spring Boot,
-->
puedes ver
-->
montones,
-->
¿no?
-->
Spring Batch,
-->
puedes ver todos
-->
los productos
-->
que trae.
-->
En este caso,
-->
nos vamos a
-->
centrar en la
-->
familia de
-->
Spring Cloud,
-->
o de la nube.
-->
Y,
-->
si te fijas,
-->
básicamente,
-->
todos estos
-->
productos
-->
son los que
-->
tú puedes
-->
ocupar
-->
para esta,
-->
para este enfoque,
-->
¿no?
-->
de la nube.
-->
A mí se me hace
-->
más
-->
práctico
-->
pues
-->
mencionarles
-->
que existe
-->
esta página
-->
en la que tú puedes
-->
ir viendo
-->
documentación
-->
en específico
-->
de cada uno
-->
de los productos.
-->
Aquí
-->
resaltan,
-->
o se ven
-->
algunos
-->
de los que
-->
nosotros vamos
-->
a estar viendo,
-->
Por ejemplo,
-->
aquí el
-->
Spring Cloud Boost,
-->
este es uno
-->
de los productos
-->
que vamos
-->
a estar viendo.
-->
El tema del
-->
Circuit Breaker,
-->
también lo vamos
-->
a estar viendo.
-->
Vamos a estar
-->
viendo lo que son
-->
los configs,
-->
vamos a estar
-->
viendo lo que son
-->
Cloud Gateway,
-->
vamos a estar
-->
viendo lo que es
-->
Netflix,
-->
vamos a estar
-->
viendo
-->
lo que es
-->
Cloud
-->
también,
-->
creo que ya
-->
es todo.
-->
Vamos a estar viendo
-->
esos productos
-->
que vienen aquí
-->
contenidos.
-->
Y si te fijas,
-->
son productos
-->
modulares porque se
-->
pueden ocupar de
-->
forma independiente
-->
en
-->
cada proyecto.
-->
No es necesario
-->
que ocupes
-->
todos como para que
-->
tú puedes tener
-->
un producto
-->
funcional de
-->
la nube,
-->
un micro
-->
servicio.
-->
Tú puedes ocupar
-->
cada uno de estos
-->
por separado.
-->
Entonces,
-->
esto es lo que
-->
también le brinda
-->
una característica
-->
muy única
-->
y muy útil
-->
a la hora
-->
de estar
-->
desarrollando
-->
proyectos.
-->
Puedes ocupar
-->
solamente
-->
lo que va
-->
requiriendo
-->
tu aplicativo.
-->
Entonces,
-->
esta es la
-->
página para que
-->
ustedes puedan
-->
meterse,
-->
la puedan ir
-->
explorando
-->
y si hay
-->
algo más que
-->
no está
-->
contenido en
-->
este temario,
-->
pues lo
-->
puedan ir viendo,
-->
lo pueden ir
-->
investigando.
-->
Hay mucha
-->
documentación
-->
y aquí en
-->
la parte,
-->
por ejemplo,
-->
de los
-->
ejemplos,
-->
creo que te lleva
-->
repositorios
-->
de GitHub incluso,
-->
donde hay
-->
muchísima
-->
información
-->
teórica
-->
y práctica
-->
que te
-->
permiten
-->
avanzar.
-->
Entonces,
-->
bueno,
-->
esta es la
-->
parte de
-->
todos estos
-->
son los
-->
subproductos
-->
de Spring Cloud.
-->
Esa es como
-->
la descripción
-->
general que
-->
podríamos ir
-->
revisando de
-->
cada uno
-->
de ellos.
-->
Esta la voy a
-->
dejar aquí
-->
abierta
-->
porque
-->
bueno,
-->
por si después
-->
la podemos
-->
estar ocupando.
-->
Claro que sí,
-->
de hecho,
-->
sabes que,
-->
yo creo que
-->
les voy a
-->
compartir ya la
-->
presentación
-->
y en la
-->
presentación ahí viene.
-->
De todos modos,
-->
la paso.
-->
De todos modos,
-->
voy a pasar la
-->
liga
-->
de Spring Cloud.
-->
A ver,
-->
¿dónde está
-->
el chat?
-->
Aquí está el chat.
-->
Y les paso
-->
esta.
-->
Y,
-->
de todos modos,
-->
también les voy a pasar
-->
la
-->
presentación.
-->
Entonces,
-->
a ver.
-->
Bueno,
-->
la presentación la voy a
-->
pasar ya se corta
-->
que nos
-->
vayamos al descanso
-->
del pomodoro.
-->
En ese ratito
-->
la voy a pasar.
-->
Entonces,
-->
esta es la
-->
parte de los
-->
subproductos que
-->
contiene
-->
la familia
-->
de Spring Cloud.
-->
¿Va?
-->
Aquí
-->
podemos
-->
repasarlo
-->
cuando
-->
tengamos que ver
-->
algún
-->
producto.
-->
Y listo.
-->
Bien,
-->
a partir de ahora,
-->
entonces,
-->
en los próximos
-->
temarios,
-->
ya entramos,
-->
digamos,
-->
en la
-->
definición de lo que
-->
es
-->
los productos
-->
de Spring Cloud
-->
que vamos a estar
-->
ocupando.
-->
¿Va?
-->
Igual,
-->
vamos a estar viendo
-->
primero su parte
-->
teórica.
-->
No,
-->
no es,
-->
no es mucho.
-->
Vamos a estar viendo
-->
básicamente definición
-->
para que se
-->
ocupa
-->
y
-->
antes de pasar ya,
-->
digamos,
-->
a la parte
-->
práctica
-->
de esto.
-->
¿Va?
-->
Entonces,
-->
el primer,
-->
o la primer
-->
familia de
-->
productos que
-->
vamos a estar viendo
-->
son el
-->
Config Server,
-->
el Config Bus,
-->
vamos a estar viendo
-->
lo que es
-->
Eureka,
-->
lo que es
-->
Reborn,
-->
lo que es
-->
Fein
-->
y lo que es
-->
este,
-->
la
-->
librería de
-->
Histex.
-->
¿Va?
-->
Entonces,
-->
para empezar con
-->
esto,
-->
vamos a hacer
-->
la pauta
-->
que nos dicta
-->
el pomodoro
-->
porque ya
-->
son,
-->
faltan 40 segundos,
-->
pero bueno,
-->
creo que es
-->
mejor hacer
-->
la pauta
-->
una vez.
-->
Y,
-->
este,
-->
son
-->
10,
-->
18,
-->
10,
-->
23,
-->
volvemos a,
-->
10,
-->
24,
-->
nos volvemos a
-->
conectar
-->
y,
-->
este,
-->
y continuamos.
-->
¿Va?
-->
Vamos a tomar entonces
-->
los cinco minutos del
-->
primer
-->
descanso del pomodoro.
-->
Perfecto.
-->
Entonces,
-->
nos vemos,
-->
10,
-->
24.
-->
Listo.
-->
¿A mí me escuchan?
-->
Perfecto.
-->
Bien,
-->
entonces,
-->
estaba viendo
-->
la parte de
-->
compartirles
-->
la presentación,
-->
pero,
-->
¿qué creen que no me deja
-->
hacer,
-->
no me deja
-->
juntar archivos?
-->
Creo que
-->
estoy
-->
algo limitado ahí
-->
por permisos.
-->
No sé si alguien
-->
me pueda,
-->
de hecho,
-->
así lo he hecho en otros
-->
cursos,
-->
ahora que lo recuerdo.
-->
No sé si me
-->
puedan alguien
-->
proporcionar
-->
algún correo
-->
personal
-->
y,
-->
y a esa
-->
persona le mandaría
-->
la presentación
-->
y,
-->
este,
-->
y ustedes
-->
que se pueden
-->
encargar de
-->
compartirla
-->
en,
-->
en algún chat que estén
-->
ahí todos,
-->
alguien me
-->
pueda compartir
-->
una.
-->
Perfecto.
-->
A ver,
-->
se lo voy a mandar
-->
a ustedes
-->
dos,
-->
y si me hacen
-->
el grandísimo
-->
favor.
-->
Ah, bueno.
-->
A ustedes tres.
-->
Ah, son dos.
-->
Listo.
-->
Se los voy a mandar.
-->
Entonces,
-->
sería
-->
para
-->
armando
-->
para Fox
-->
y para
-->
Jim Paul.
-->
Sale.
-->
Entonces,
-->
se los mando
-->
y porfa,
-->
ayúdenme a pasárselo
-->
a los demás.
-->
Listo.
-->
Entonces,
-->
en cuanto les llegue,
-->
pues ya ellos nos,
-->
nos ayudarían a,
-->
a compartir la,
-->
la presentación.
-->
¿Sale?
-->
Bien,
-->
va.
-->
Entonces,
-->
a ver,
-->
voy a poner la siguiente
-->
alarma.
-->
Son otros,
-->
vamos a poner
-->
otros 45 minutos.
-->
Listo.
-->
Sale.
-->
Entonces,
-->
continuamos con la parte
-->
de lo que es
-->
Config Server,
-->
lo que es el VOS,
-->
lo que es Eureka,
-->
lo que es Ribbon,
-->
lo que es Fein,
-->
lo que es,
-->
este,
-->
Hystrix.
-->
Sale.
-->
Entonces,
-->
Config Server
-->
permite la gestión
-->
centralizada de la configuración
-->
de los microservicios.
-->
Actúa como
-->
un repositorio central
-->
donde se almacenan
-->
los archivos de configuración.
-->
El Config VOS
-->
es una característica adicional
-->
que permite la actualización
-->
dinámica
-->
de la configuración
-->
en tiempo de ejecución,
-->
lo que facilita la
-->
implementación de cambios
-->
sin reiniciar los servicios.
-->
Entonces,
-->
eh,
-->
los que hemos hecho
-->
aplicaciones con Java,
-->
con Spring,
-->
eh,
-->
ubicamos lo que son
-->
los archivos,
-->
los properties,
-->
Los archivos de configuración
-->
que
-->
ahorita también
-->
ya hay otros formatos,
-->
el YAML,
-->
por ejemplo.
-->
Sí,
-->
sí,
-->
ubican esos archivos properties,
-->
los de config,
-->
los de configuración.
-->
Sí,
-->
son algunos YAML,
-->
algunos son archivos properties,
-->
otros son bootstraps.
-->
Perfecto.
-->
Va.
-->
Entonces,
-->
dentro de estos,
-->
estos archivos
-->
que
-->
tú haces cuando creas
-->
una,
-->
una aplicación,
-->
eh,
-->
muchos de esos son archivos
-->
para darle configuración
-->
al,
-->
al proyecto,
-->
¿no?
-->
Se guardan variables de entorno,
-->
variables de sistemas,
-->
secretos,
-->
bueno,
-->
o sea,
-->
se guardan
-->
configuraciones adicionales,
-->
¿no?
-->
Se guarda,
-->
por ejemplo,
-->
la conexión a la base de datos,
-->
etcétera,
-->
etcétera.
-->
Entonces,
-->
ese tipo de servicios,
-->
lo que la propuesta
-->
de Config Server trae
-->
es que tú puedes,
-->
eh,
-->
en un arquitecto
-->
de microservicios,
-->
puedes,
-->
puedes quitar
-->
esos archivos de configuración
-->
que son
-->
globales,
-->
por así decirlo,
-->
a todos los,
-->
los microservicios,
-->
ajá,
-->
que,
-->
o sea,
-->
vas a,
-->
vas a crear,
-->
eh,
-->
un repositorio,
-->
básicamente,
-->
donde vas a guardar
-->
esos archivos de configuración
-->
que son globales
-->
a todos los microservicios
-->
y los puedes almacenar
-->
de esa forma,
-->
ajá.
-->
Entonces,
-->
eso te va a evitar
-->
que tú
-->
tengas un,
-->
en cada microservicio
-->
que tú guardes
-->
esos archivos
-->
de configuración,
-->
a,
-->
a lo mejor,
-->
este,
-->
quieres guardar algo
-->
que es muy,
-->
que,
-->
que tiene información
-->
muy,
-->
muy sensible,
-->
como una contraseña
-->
o algo así,
-->
lo puedes meter
-->
a un servidor
-->
distribuido,
-->
que para eso
-->
es el Config Server,
-->
ajá,
-->
y,
-->
eh,
-->
todos los micros,
-->
como es un servidor,
-->
va a esperar,
-->
este,
-->
clientes,
-->
todos los microservicios
-->
que en este caso serían
-->
tus clientes
-->
que se conecten
-->
a ese Config Server
-->
o a ese servidor
-->
de configuración,
-->
van a poder descargar
-->
a,
-->
a través de él
-->
esa,
-->
esa configuración interna,
-->
ajá,
-->
eso,
-->
eso es lo que nos permite hacer
-->
el Config Server,
-->
¿sí?
-->
El Config Server
-->
más adelante
-->
vamos a ver
-->
que además de,
-->
de,
-->
del servidor
-->
necesita un
-->
Config Repo,
-->
o,
-->
bueno,
-->
la buena práctica
-->
te permite crear
-->
un Config Repo,
-->
que básicamente
-->
es un repositorio
-->
en GitHub,
-->
bueno,
-->
es una opción,
-->
¿no?
-->
Porque no puedes guardar
-->
en,
-->
en archivos incluso
-->
locales,
-->
pero,
-->
digamos,
-->
una buena práctica
-->
lo guardas en un repositorio
-->
en GitHub,
-->
ahí está el Config Repo,
-->
guardas ahí
-->
los archivos
-->
de configuración,
-->
el Config Server
-->
se conectaría
-->
a ese Config Repo,
-->
y todos los clientes
-->
que se conectan
-->
a ese Config Server,
-->
van a poder tener
-->
la,
-->
la,
-->
los archivos
-->
de configuración,
-->
¿va?
-->
Desde ahí lo van a poder
-->
agarrar.
-->
Y el Config Bus,
-->
lo que hace
-->
es,
-->
este,
-->
nos permite
-->
actualizar,
-->
digamos,
-->
esas propiedades
-->
de forma dinámica,
-->
sin que tú tengas
-->
que apagar un microservicio.
-->
Por ejemplo,
-->
imagínate que
-->
el día de mañana
-->
cambian la,
-->
cambian la conexión
-->
a la base de datos,
-->
¿no?
-->
Mandan un correo,
-->
la gente de infraestructura,
-->
o de DevOps,
-->
y nos dicen que
-->
el,
-->
el servidor
-->
y la contraseña del,
-->
del microservicio
-->
de la base de datos
-->
de,
-->
de un microservicio X
-->
cambia,
-->
Que,
-->
que tienes que hacer
-->
ese cambio.
-->
Que todos se tienen
-->
que cambiar a,
-->
a eso nuevo que se,
-->
que se,
-->
que se modificó.
-->
Entonces,
-->
este,
-->
el flujo normal,
-->
pues tú apagarías
-->
tu servicio,
-->
le hablas
-->
a un desarrollador
-->
para que haga
-->
el cambio,
-->
lo,
-->
lo sube al repositorio,
-->
se despliega,
-->
se vuelve a hacer
-->
un despliegue,
-->
¿no?
-->
Entonces ahí tú tuviste
-->
que apagar el microservicio,
-->
si tú quieres cinco minutos,
-->
pero no apagas,
-->
¿no?
-->
Entonces,
-->
el config bus,
-->
lo que nos permite hacer es,
-->
si tú configuras un bus,
-->
dentro de esta
-->
arquitectura que estamos hablando del config server,
-->
este,
-->
tú nada más haces un commit,
-->
hacia un,
-->
hacia el repositorio
-->
en donde tienes guardado el,
-->
el archivo,
-->
haces el cambio,
-->
y con ese commit es suficiente
-->
para que el bus
-->
ayude a propagar
-->
a los microservicios,
-->
y les diga que cambió
-->
cierta propiedad,
-->
sin que,
-->
sin que apagues,
-->
sin que apagues nada,
-->
¿no?
-->
Sin que apagues algún microservicio,
-->
nada.
-->
Entonces,
-->
ese config bus,
-->
ahorita nosotros lo vamos a ver en la práctica,
-->
con,
-->
con un Kafka,
-->
¿no?
-->
Vamos a instalar por ahí Kafka,
-->
que,
-->
aunque su principal función es ser un,
-->
un sistema
-->
o una aplicación de encolamiento,
-->
de mensajes,
-->
también lo vamos a poder escuchar como un,
-->
digo,
-->
lo vamos a poder utilizar como un propagador de eventos,
-->
¿va?
-->
Eso trae las características que trae Kafka,
-->
y para eso,
-->
para esa,
-->
esa propagación,
-->
de,
-->
de cierto evento que ocurre sobre un repositorio,
-->
es que lo vamos a ocupar,
-->
¿va?
-->
Entonces,
-->
eso básicamente es el config bus,
-->
eh,
-->
el config bus lo puedes ocupar,
-->
ya sea con RabbitMQ,
-->
lo puedes ocupar con Kafka,
-->
lo puedes ocupar con cualquier software,
-->
que se dedique a hacer este tipo de,
-->
que tenga estos,
-->
estos mecanismos,
-->
¿no?
-->
La propuesta,
-->
pues,
-->
que traemos es utilizar Kafka,
-->
y así vamos a hacer esa configuración de,
-->
de estos,
-->
este,
-->
de esta primer familia de,
-->
de productos,
-->
Entonces,
-->
eso es el config server,
-->
lo que es el config bus a nivel platicado,
-->
¿vale?
-->
Eh,
-->
luego viene la parte de Spring Cloud Netflix,
-->
este,
-->
y,
-->
básicamente,
-->
este,
-->
este producto,
-->
que de hecho,
-->
por aquí,
-->
si se acuerdan,
-->
lo llegamos a ver por ahí,
-->
aquí está,
-->
Cloud Netflix,
-->
Netflix,
-->
este,
-->
trae tres subproyectos,
-->
eso es,
-->
bueno,
-->
trae,
-->
trae varios subproyectos,
-->
de los que nos pide ver el temario son,
-->
Eureka,
-->
Ribbon,
-->
Fein,
-->
y Hystrix,
-->
¿no?
-->
Eh,
-->
se llama Cloud Netflix,
-->
tal cual,
-->
porque,
-->
eh,
-->
literal,
-->
la empresa que se dedica a hacer streaming,
-->
¿no?
-->
El,
-->
las series de Netflix,
-->
esa empresa,
-->
ellos son muy,
-->
son,
-->
son de hecho muy pioneros en la parte de la creación de microservicios,
-->
entonces,
-->
imagínate que su aplicativo es muy,
-->
muy,
-->
muy famoso,
-->
muy,
-->
por,
-->
porque realmente,
-->
es muy funcional,
-->
o sea,
-->
Netflix es,
-->
es muy,
-->
muy funcional,
-->
¿no?
-->
Ha sufrido pocas caídas,
-->
o sea,
-->
realmente,
-->
es muy funcional la,
-->
la aplicación que ellos traen,
-->
y,
-->
y entonces ellos,
-->
eh,
-->
hablan de que tienen toda su infraestructura o la mayoría de su infraestructura basada
-->
en microservicios,
-->
y,
-->
pues bueno,
-->
como aporte que dan a la comunidad de la nube,
-->
eh,
-->
lanzan bibliotecas,
-->
que son,
-->
que son,
-->
algunas son,
-->
se encuentran en estos productos,
-->
para que las,
-->
las puedas ocupar en tus,
-->
en tus ideas,
-->
¿no?
-->
En tus proyectos,
-->
y puedas basarte en su propuesta de infraestructura que traen ellos,
-->
¿no?
-->
Su arquitectura.
-->
Entonces,
-->
esto ha sido muy aceptado por la comunidad de desarrolladores,
-->
y pues bueno,
-->
la parte de Netflix,
-->
Netflix tiene bibliotecas para Spring,
-->
tiene bibliotecas,
-->
para ahí también las he visto,
-->
para lo que es Apollo,
-->
con,
-->
con GraphQL,
-->
con este,
-->
por ahí he visto también con Node,
-->
entonces,
-->
es,
-->
es una,
-->
iniciativa ya bastante multiplataforma,
-->
¿no?
-->
Entonces,
-->
Spring o Java no se queda atrás,
-->
y pues bueno,
-->
desarrollan la parte para Spring Cloud,
-->
y esos son algunos de los productos que,
-->
que tiene,
-->
¿va?
-->
Entonces,
-->
este,
-->
Eureka nos va a ayudar,
-->
en así platicado,
-->
para hacer descubrimiento de servicios,
-->
¿qué es el descubrimiento de servicios?
-->
Pues básicamente es,
-->
que por medio de,
-->
eh,
-->
él va a enmascarar,
-->
digamos,
-->
todo lo que son las,
-->
las direcciones IP,
-->
y todo lo que tú,
-->
todo lo que está detrás de,
-->
que se necesita para,
-->
hacerle una llamada a un microservicio,
-->
Eureka lo va a conocer,
-->
y solamente por medio de una propiedad,
-->
que es el Name,
-->
que tú,
-->
el Name,
-->
que tú configuras en los archivos de configuración,
-->
de cada microservicio,
-->
con eso va a ser suficiente,
-->
para que Eureka,
-->
los conozca,
-->
y los identifique a todos los microservicios,
-->
que se,
-->
que se conectan a este cliente,
-->
perdón,
-->
a este servidor,
-->
¿va?
-->
Entonces,
-->
eso nos va a ser muy útil,
-->
porque cuando tú quieras hacer llamadas,
-->
a,
-->
a otros microservicios,
-->
pues,
-->
no los llamas por medio de la,
-->
de la URL,
-->
¿no?
-->
Del dominio,
-->
del localhost,
-->
no,
-->
no es necesario,
-->
simplemente es utilizar el nombre,
-->
y con eso ya,
-->
van a,
-->
van a poder con,
-->
conectarse,
-->
¿va?
-->
Ribon,
-->
es un mecanismo,
-->
que viene,
-->
casi,
-->
casi embebido en Eureka,
-->
y nos va a permitir hacer balanceo de carga,
-->
¿no?
-->
El concepto de balanceo de carga es,
-->
este,
-->
distribuir,
-->
literalmente,
-->
la,
-->
las peticiones,
-->
el tráfico que llega de un,
-->
a un,
-->
a un microservicio,
-->
a un servidor,
-->
distribuirlo en diferentes instancias,
-->
¿va?
-->
Entonces,
-->
esto,
-->
yo no soy muy de,
-->
de hacer redes,
-->
de hacer todo este tipo de cosas,
-->
o infraestructura,
-->
pero,
-->
pero sí,
-->
estoy familiarizado con,
-->
sobre todo,
-->
en el,
-->
en el,
-->
como se hacía antes,
-->
Hacer esto,
-->
era,
-->
era un desafío,
-->
¿no?
-->
Para las personas involucradas,
-->
meter instancias,
-->
este,
-->
balanceo de carga,
-->
eh,
-->
y bueno,
-->
ahorita,
-->
con el tema de que estábamos platicando,
-->
de los proveedores de Nubay,
-->
y el diseño nativo de Nubay,
-->
y demás,
-->
pues,
-->
básicamente tú le pagas ya a un proveedor,
-->
y él solito se encarga de hacer,
-->
N instancias,
-->
a conforme las,
-->
el tráfico,
-->
y llega a tu,
-->
a tu aplicativo,
-->
Yo,
-->
yo lo digo a nivel,
-->
de desarrolladores,
-->
estoy hablando con,
-->
con desarrolladores,
-->
este,
-->
eh,
-->
es muy útil,
-->
¿no?
-->
Utilizar,
-->
que,
-->
que nos provean de un servicio así,
-->
en el tibio,
-->
no me voy a preocupar por,
-->
eh,
-->
desarrollar una estrategia de,
-->
aprovisionamiento de instancias,
-->
de escalamiento,
-->
horizontal,
-->
vertical,
-->
no me voy a preocupar por nada de eso,
-->
simplemente,
-->
yo desarrollo,
-->
y,
-->
eh,
-->
utilizando librerías como estos,
-->
voy a poder,
-->
este,
-->
tener una aplicación,
-->
con alta,
-->
con alta demanda,
-->
¿no?
-->
Que este,
-->
24-7,
-->
entre comillas,
-->
porque a veces también,
-->
Amazon,
-->
Google,
-->
pues también se caen,
-->
¿no?
-->
Pero bueno,
-->
la,
-->
en un mundo ideal,
-->
te permiten,
-->
estar en un 24-7,
-->
¿no?
-->
Todo tu aplicativo.
-->
La librería de Fein,
-->
igual platicado,
-->
ahorita,
-->
es una librería que nos va a permitir,
-->
hacer peticiones,
-->
entre servicios,
-->
entre microservicios,
-->
¿sí?
-->
Entonces,
-->
eh,
-->
en el ejemplo que estamos poniendo,
-->
que vamos a hacer,
-->
tenemos,
-->
este,
-->
las tres entidades son los usuarios,
-->
son los productos,
-->
son las órdenes,
-->
eh,
-->
tú puedes crear un usuario,
-->
sin que necesites conocer nada de los otros,
-->
¿no?
-->
Tú puedes crear un producto,
-->
igual,
-->
sin necesidad de conocer nada de los otros,
-->
pero,
-->
tú,
-->
cuando quieras crear una orden,
-->
una orden,
-->
sí necesita conocer,
-->
qué usuario es,
-->
o a qué usuario se lo va a asignar,
-->
y,
-->
y sobre todo,
-->
qué producto,
-->
qué producto va,
-->
a,
-->
a despachar,
-->
para que se genere la orden,
-->
Entonces,
-->
en este ejemplo que traemos,
-->
eh,
-->
en el microservicio de órdenes,
-->
vamos a hacer dos Fein Clients,
-->
para que se conecten,
-->
a los microservicios de usuario,
-->
y al de productos,
-->
y pueda comunicarse,
-->
¿va?
-->
Ese es el objetivo del Fein,
-->
que pueda mostrar información de otros,
-->
este,
-->
de otros microservicios.
-->
¿Va?
-->
Y,
-->
por último,
-->
la parte de Hystrix,
-->
que les decía que ya está,
-->
poquito está actualizado,
-->
estamos ocupando más bien,
-->
otra librería,
-->
pero,
-->
al final,
-->
el concepto,
-->
es el mismo,
-->
¿no?
-->
El patrón que vamos a estar aplicando,
-->
es el del,
-->
el del Circuit Breaker,
-->
que básicamente,
-->
es un patrón,
-->
de diseño,
-->
que,
-->
te permite,
-->
aplicar tolerancia a fallos,
-->
¿no?
-->
Quiere decir que si,
-->
alguna comunicación,
-->
exclusivamente,
-->
de Fein Client,
-->
eh,
-->
truena,
-->
o falla,
-->
por alguna razón,
-->
imagínate que se cayó,
-->
el microservicio de,
-->
usuarios.
-->
O sea,
-->
tú quieres crear una orden,
-->
y se cae el microservicio de usuarios,
-->
o no está disponible.
-->
Eh,
-->
cuando tú quieres hacer el Fein Client,
-->
así,
-->
desde órdenes,
-->
hacia usuarios,
-->
pues va a haber un error,
-->
porque,
-->
está,
-->
no responde.
-->
Entonces,
-->
para eso es Hystrix,
-->
Eh,
-->
bueno,
-->
el concepto del Circuit Breaker,
-->
lo que va a hacer,
-->
es,
-->
ok,
-->
si ahorita no está respondiendo,
-->
ese llamado,
-->
eh,
-->
no te preocupes,
-->
va a caer en un,
-->
en un método,
-->
que se conoce como fallback,
-->
¿sí?
-->
Y,
-->
ahí va a estar procesándose,
-->
todo lo fallido.
-->
Y,
-->
ahí tú puedes hacer lo que tú,
-->
lo que se te ocurra.
-->
Imagínate que puedes guardarlo,
-->
por ejemplo,
-->
en un Kafka,
-->
¿no?
-->
Puedes crear mensajes de encolamiento,
-->
que se guarden,
-->
y,
-->
el día,
-->
bueno,
-->
más al gatito,
-->
que ya esté disponible ese servicio,
-->
o sea,
-->
todo lo que quedó ahí en,
-->
en colado,
-->
se vuelva a procesar.
-->
Entonces,
-->
así ya no perdiste,
-->
las órdenes que fuiste creando,
-->
Ese es básicamente el concepto,
-->
de lo que es,
-->
este,
-->
el Circuit Breaker,
-->
¿va?
-->
Entonces,
-->
de esta,
-->
de este conjunto de,
-->
de productos,
-->
¿les queda,
-->
alguna duda,
-->
alguna inquietud,
-->
tienen algún comentario,
-->
o,
-->
es clara,
-->
la,
-->
la definición de todos y cada uno,
-->
o,
-->
algo que quieran,
-->
este,
-->
que andemos en detalle.
-->
Digo,
-->
esto fue a nivel teórico,
-->
claro que sí,
-->
claro que sí,
-->
sin,
-->
sin mayor problema,
-->
¿vale?
-->
Entonces,
-->
vean,
-->
hablando de config server,
-->
y,
-->
y el config bus,
-->
¿vale?
-->
Entonces,
-->
eh,
-->
para hablar del config server,
-->
hay que,
-->
hablar,
-->
poquito más,
-->
con más detalle,
-->
de lo que son,
-->
los archivos de propiedades,
-->
¿va?
-->
Entonces,
-->
cuando tú tienes una aplicación,
-->
ahorita,
-->
imaginate una aplicación,
-->
monolítica,
-->
si tú quieres,
-->
en,
-->
en,
-->
Spring Boot,
-->
o,
-->
en Spring Framework,
-->
eh,
-->
no sé si te ha tocado,
-->
o,
-->
les ha tocado,
-->
crear,
-->
al menos interactuar,
-->
con,
-->
con unos archivos que son,
-->
cuya extensión tiene properties,
-->
¿no?
-->
Ah,
-->
eh,
-->
Application Properties,
-->
o,
-->
Application Jamel,
-->
o,
-->
hay otras que se llaman,
-->
Application Bootstrap,
-->
no es cierto,
-->
se llama Bootstrap Jamel,
-->
eh,
-->
ese tipo de archivos,
-->
son los archivos de configuración,
-->
ajá,
-->
esos archivos de configuración,
-->
ahí tú guardas,
-->
por ejemplo,
-->
cosas como,
-->
la conexión a base de datos,
-->
Para irnos,
-->
este,
-->
eh,
-->
sobre un ejemplo,
-->
podemos hablar de que,
-->
en esos archivos de configuración,
-->
están las bases de datos,
-->
está con el,
-->
el connection string,
-->
¿va?
-->
Entonces,
-->
eh,
-->
esos,
-->
esos archivos de configuración,
-->
por ejemplo,
-->
te sirven para dictar cómo va a trabajar la parte de Hibernet,
-->
eh,
-->
etcétera,
-->
etcétera,
-->
o sea,
-->
al final de cuentas,
-->
son archivos de configuración,
-->
¿va?
-->
Entonces,
-->
la propuesta del config server,
-->
es,
-->
esos archivos de configuración,
-->
que tienen tus microservicios,
-->
tú las puedes aislar,
-->
o sea,
-->
no dictes esos,
-->
esos archivos properties,
-->
dentro de cada microservicio,
-->
sino que,
-->
tú lo puedes aislar,
-->
y lo puedes mandar a otro lugar,
-->
ese,
-->
ese otro lugar,
-->
se recomienda que sea un repositorio en Git,
-->
ajá,
-->
entonces,
-->
tú en,
-->
todo esto lo vamos a ver en la práctica,
-->
o sea,
-->
ahorita lo estoy dictando,
-->
teóricamente,
-->
pero,
-->
tú lo vas a ver guardado,
-->
o almacenado,
-->
en un repositorio en Git,
-->
ajá,
-->
y en Git vas a tener,
-->
por ejemplo,
-->
cuatro archivos de propiedades,
-->
ajá,
-->
que corresponden a cuatro microservicios,
-->
¿sí?
-->
Entonces,
-->
el config server,
-->
precisamente,
-->
lo que,
-->
la propuesta que trae,
-->
Spring,
-->
con esto es,
-->
que tú puedas aislar esos archivos de propiedades,
-->
y servirlos,
-->
por eso son server,
-->
se lo vas a servir a todos los microservicios clientes,
-->
que se conecten a ese servidor,
-->
¿va?
-->
Entonces,
-->
esas configuraciones,
-->
en vez de traerlas internamente,
-->
las van a traer desde un servidor,
-->
y ese servidor se va a conectar a un repositorio.
-->
¿Para qué es esto?
-->
Pues,
-->
probablemente porque tú quieras guardar la,
-->
la,
-->
¿cómo se llama?
-->
Que sean,
-->
que sea información muy sensible,
-->
¿no?
-->
Probablemente es información muy sensible,
-->
que no quieras que viva dentro de tu repositorio,
-->
ah, bueno,
-->
lo vas y lo guardas al repositorio de GitHub,
-->
¿va?
-->
Y,
-->
además de eso,
-->
tiene otra,
-->
otra,
-->
otra función de ser,
-->
¿no?
-->
Tiene otra,
-->
tiene otro mecanismo,
-->
que es el config bus.
-->
Ese config bus,
-->
les decía que,
-->
es una característica adicional,
-->
que nos va a ayudar a hacer este,
-->
a propagar el cambio,
-->
en una propiedad,
-->
de esos archivos de configuración,
-->
hacia los clientes que están,
-->
conectados.
-->
Es decir,
-->
que,
-->
que si tú,
-->
por ejemplo,
-->
haces un cambio,
-->
haces un commit,
-->
en ese repositorio que contienen los archivos de configuración,
-->
y cambias,
-->
por ejemplo,
-->
el valor del connection string,
-->
de uno de los cuatro microservicios que estábamos hablando,
-->
en automático,
-->
ese config bus,
-->
le va a propagar el valor de esa nueva propiedad que se cambió,
-->
hacia el microservicio correspondiente.
-->
Ajá.
-->
Y ese bus,
-->
ahorita nosotros tenemos la propuesta,
-->
de mostrar cómo se configura,
-->
con un software que se llama Kafka.
-->
Ajá.
-->
Entonces Kafka nos va a permitir,
-->
Kafka funciona como un,
-->
es un producto para hacer encolamento,
-->
Procesar encolamiento masivo.
-->
Pero también,
-->
dentro de las cosas que tiene Kafka,
-->
es que,
-->
sirve como propagador de eventos.
-->
Es decir,
-->
que Kafka,
-->
reacciona a eventos que escucha.
-->
Entonces,
-->
con estos eventos,
-->
que él puede estar escuchando,
-->
sobre el repositorio de GitHub,
-->
es que se,
-->
es que se desarrolla el bus.
-->
Ajá.
-->
Entonces,
-->
ese bus puede,
-->
avisarle al microservicio correspondiente,
-->
cuando una de sus propias cambio,
-->
y sin que tú tengas que estar apagando algo,
-->
o reiniciando el microservicio,
-->
o haciendo un nuevo despliegue,
-->
la información,
-->
las variables,
-->
los valores de las variables de configuración,
-->
van a cambiar en automático.
-->
¿Va?
-->
Entonces yo les ponía el ejemplo de,
-->
imaginemos un caso,
-->
en el que,
-->
para,
-->
hablando de esta familia de,
-->
de productos,
-->
imaginemos un caso,
-->
en el que tú ya tienes tu aplicación levantada,
-->
tienes,
-->
por microservicio,
-->
¿Va?
-->
Y,
-->
manda en un correo,
-->
¿No?
-->
La parte de DevOps,
-->
y te contacta,
-->
la persona que esté ahí,
-->
trabajando contigo,
-->
y te dice,
-->
oye, ¿Sabes qué?
-->
Te cambiaron la,
-->
la,
-->
la conexión de base de datos,
-->
cambiaron el servidor,
-->
o sea, se cambió todo,
-->
este microservicio ya no se conecta a esa base de datos,
-->
¿No?
-->
Se conecta ahora,
-->
a otra.
-->
Se debe hacer ese cambio,
-->
¿Va?
-->
En un flujo normal,
-->
tú,
-->
le pides a un desarrollador que haga el cambio,
-->
lo,
-->
lo,
-->
lo hace,
-->
al final tienes que hacer un,
-->
un nuevo despliegue,
-->
¿No?
-->
De ese cambio,
-->
para que se vayan,
-->
las,
-->
las nuevas actualizaciones,
-->
a tu base de datos.
-->
Ajá.
-->
Este,
-->
lo que hace este,
-->
este mecanismo del config server,
-->
y el config bus,
-->
en ese escenario,
-->
el flujo sería,
-->
que,
-->
imagínate que te avisan,
-->
que ya te,
-->
que se cambió esto,
-->
la base de datos,
-->
demás,
-->
tú lo único que tendrías que hacer,
-->
es un commit,
-->
sobre el repositorio,
-->
en donde se encuentra,
-->
esas,
-->
esas variables,
-->
de,
-->
de conexión,
-->
hacia la base de datos,
-->
haces un commit,
-->
haces el cambio,
-->
directamente,
-->
en el repositorio,
-->
y ya,
-->
o sea,
-->
sin que tú apagues,
-->
ningún servicio,
-->
ni nada,
-->
el bus,
-->
en automático,
-->
va a tomar la propiedad,
-->
que cambiaste,
-->
y la va a propagar,
-->
al,
-->
al microservicio,
-->
correspondiente,
-->
¿Sí?
-->
Y,
-->
y por eso,
-->
por eso aquí se habla,
-->
de la actualización dinámica,
-->
de la configuración,
-->
en tiempo de ejecución,
-->
tú no tienes que detener nada,
-->
simple y sencillamente,
-->
ni reiniciar ningún micro,
-->
simplemente,
-->
hacer un commit,
-->
¿Va?
-->
No sé si más o menos,
-->
queda un poquito más claro,
-->
lo que es config server,
-->
y config bus,
-->
perfecto,
-->
sale,
-->
súper,
-->
y entonces,
-->
y todo esto,
-->
les comento,
-->
lo vamos a ver,
-->
en,
-->
en la práctica,
-->
¿Va?
-->
No necesito que ahorita,
-->
quede un poquito claro el concepto,
-->
y después lo vamos a ir retomando,
-->
en,
-->
en la práctica,
-->
¿Va?
-->
Y,
-->
después viene el otro concepto,
-->
de la parte de,
-->
Spring Cloud Netflix,
-->
que,
-->
les decía,
-->
este,
-->
este,
-->
como tal,
-->
no es un producto,
-->
sino es una familia,
-->
de subproductos,
-->
¿Ajá?
-->
Dentro de esos subproductos,
-->
que contiene,
-->
pues,
-->
son Eureka,
-->
lo que es Reborn,
-->
lo que es el Fame Client,
-->
lo que es Histrix,
-->
y,
-->
pues,
-->
bueno,
-->
les explicaba que,
-->
es,
-->
es pionero en esto,
-->
y,
-->
pues,
-->
bueno,
-->
todo lo que ofrezca,
-->
de librerías,
-->
de consejos,
-->
de buenas prácticas,
-->
pues,
-->
es,
-->
bastante bien incluido,
-->
y tomado,
-->
por frameworks,
-->
tan,
-->
robustos,
-->
como lo es Spring,
-->
¿No?
-->
Entonces,
-->
Spring Cloud,
-->
lo toma,
-->
estos,
-->
estos,
-->
este,
-->
los subproductos,
-->
y,
-->
por ejemplo,
-->
la parte de Eureka,
-->
Eureka es un servicio,
-->
que nos permite,
-->
este,
-->
hacer descubrimiento,
-->
descubrimiento de microservicios,
-->
el,
-->
el término de descubrimiento,
-->
se refiere a,
-->
a,
-->
a lo mejor,
-->
un ejemplo más práctico,
-->
cuando tú quieres hacer,
-->
una,
-->
una petición,
-->
eh,
-->
HTTP,
-->
a una API,
-->
eh,
-->
que está en,
-->
por ejemplo,
-->
te quieres comunicar con el API de,
-->
de,
-->
de envíos,
-->
¿No?
-->
De un proveedor,
-->
como DHL.
-->
Entonces,
-->
tú necesitas meter ahí,
-->
la,
-->
la URL,
-->
al,
-->
al,
-->
al ambiente,
-->
a donde te vas a conectar,
-->
¿No?
-->
Puede ser que te den un sandbox,
-->
un ambiente de desarrollo,
-->
un ambiente de producción,
-->
¿No?
-->
Bueno,
-->
como lo maneje.
-->
Te tienes que conectar por medio de una URL,
-->
¿Va?
-->
Y a veces tienes que estar,
-->
lidiando con problemas,
-->
como el course,
-->
¿No?
-->
El de los,
-->
los,
-->
los,
-->
los,
-->
los,
-->
los,
-->
los,
-->
los,
-->
los losood利
-->
y les dices cómo se llaman,
-->
Eureka en automático hace todo ese mapeo, por así decirlo,
-->
y permite que todos los que estén conectados a este microservicio
-->
se conozcan por ese name.
-->
Por ejemplo, en este caso,
-->
el microservicio de usuario, producto y órdenes,
-->
ya no es necesario que se comuniquen por medio del URL,
-->
sino que ya nada más por el mismo name
-->
se van a mandar a llamar.
-->
Entonces, eso a nivel de líneas de código,
-->
pues está muy chido, porque nada más le pones el name
-->
y ya, el solito de Eureka sabe quién es,
-->
hacia dónde tiene que redireccionar la petición.
-->
Eureka, dentro de todas sus demás features
-->
o características que tiene,
-->
tiene también el tema del balanceo de carga.
-->
Y por eso les decía que casi, casi vienen estos.
-->
Adelante, Iván.
-->
Exacto.
-->
Exacto, exactamente.
-->
Es correcto, correcto.
-->
Esa es como su función.
-->
Exactamente.
-->
Perfecto.
-->
No de nada. Sí, exactamente.
-->
Ese otro escenario que nos comparte, Iván,
-->
es válido y es manejado por Eureka.
-->
Si ese puerto cambia, si esa IP cambia,
-->
Eureka, él sabe.
-->
Con solo decirle quién es el name
-->
dentro del archivo de properties,
-->
lo vamos a ver, pero básicamente ese name
-->
se guarda en el archivo properties
-->
de cada microservicio.
-->
Con eso ya Eureka lo tiene en la mira, por así decirlo.
-->
Y todo lo que haga en relación a las IPs y demás
-->
lo va a conocer y lo va a enmascarar.
-->
La parte de Ribbon que les decía viene embebida en Eureka
-->
es para hacer el tema del balanceo de carga.
-->
Y básicamente el balanceo de carga es eso.
-->
Es distribuir el tráfico entre las N instancias
-->
que puedan crearse para procesar estas peticiones.
-->
Les decía que esta parte de Ribbon sí la vamos a ver
-->
en este temario.
-->
Más bien en el ambiente meramente teórico.
-->
Porque no nos montamos a un servicio de nube como para
-->
hacer instancias dinámicas.
-->
Habría que ver la forma de generar mucho tráfico.
-->
O sea, es algo posible, pero la verdad es que se salió un poco
-->
del tiempo de este curso.
-->
La parte del Faint Client es un mecanismo que nos permite
-->
conectarnos.
-->
Conectarnos o comunicarnos entre otros microservicios.
-->
Entonces, en este Faint Client les explicaba el
-->
concepto de lo que es este.
-->
En el ejemplo que traemos nosotros tenemos tres unidades.
-->
Tres entidades que son el usuario.
-->
Las órdenes que son muchos a muchos entre producto y usuario.
-->
Y el producto.
-->
Bueno, vamos a ponerlo en plural.
-->
Productos, usuarios y órdenes.
-->
Entonces, yo puedo dar de alta usuarios sin necesidad de
-->
conocer órdenes o productos.
-->
Es independiente.
-->
De la misma forma yo puedo dar de alta productos.
-->
Puedo dar de alta productos con un stock,
-->
una cantidad, lo que tú quieras.
-->
Y no necesito conocer ninguno de los otros dos.
-->
Pero, ¿qué pasa con las órdenes?
-->
Si yo quisiera pedir una orden, ¿sí?
-->
De entrada, hasta el mismo enunciado te lo dice, ¿no?
-->
Una orden de qué producto y a qué usuario, ¿no?
-->
Entonces, para que tú puedas tener una orden de un
-->
producto y para un usuario, pues tú necesitas conocer de
-->
órdenes qué productos hay disponibles y qué usuarios
-->
existen.
-->
Entonces, órdenes es el microservicio que en este ejemplo
-->
se va a estar comunicando por Fame Client a los otros dos
-->
microservicios.
-->
Para que cuando tú hagas un post de orden,
-->
o sea, crees una orden, primero veas si existe el
-->
producto que te están pidiendo y el usuario al que
-->
se lo estás asignando, ¿va?
-->
Ese es el Fame Client.
-->
Nos va a permitir comunicarnos.
-->
Y al estar todos bajo la red de Bureka,
-->
solamente van a ocupar el name.
-->
O sea, yo le voy a decir, vete a productos, así literal,
-->
al name, microservicio de productos,
-->
y tráeme su información o al de usuarios, ¿va?
-->
Eso es Fame Client.
-->
Y el history es un mecanismo que ocupa un patrón de
-->
diseño que se llama Circuit Breaker, corto circuito,
-->
que lo que te permite hacer es que cuando las conexiones
-->
con Fame Client fallen, imagínate que usuarios en
-->
este momento, pues, están muertos, ¿no?
-->
Entonces, si tú quieres hacer una orden y te respondió
-->
productos, pero usuarios no, en un flujo normal,
-->
quien no aplique el mecanismo de corto circuito,
-->
pues, se truena, ¿no?
-->
Se muere y ahí vas a tener un problema.
-->
Porque imagínate, son órdenes y estás vendiendo.
-->
Y por no haber usuarios, pues, ya te perdiste de
-->
ventas, ¿no?
-->
Pero, ¿qué pasa?
-->
History, bueno, no es tanto history,
-->
sino más bien el concepto del Circuit Breaker.
-->
Lo que va a hacer es, OK, si está fallando el microservicio
-->
de usuarios, no te apures.
-->
Vamos a crear un fallback, ¿sí?
-->
Que es un método, digamos, de recuperación que te va a
-->
decir, si falla el mecanismo hacia usuarios,
-->
vamos a tener un fallback de usuarios.
-->
Y lo que va a hacer es hacer un algo.
-->
Aquí tú vas a poder ya hacer cualquier cosa, ¿sí?
-->
Aquí ya vas a poder hacer cualquier mecanismo para que
-->
esa petición no se pierda.
-->
Cualquier cosa, me refiero, por ejemplo,
-->
lo mandas a una cola, por ejemplo,
-->
RabbitMQ o lo mandas a Kafka, ¿no?
-->
Por ejemplo, como sistema de encolamiento.
-->
O lo guardas en una base de datos con logs de fallidos.
-->
O puedes hacer lo que tú quieras, ¿no?
-->
O enviar correos y les dices,
-->
por ahorita tu petición no la puedo atender.
-->
Pero más al rato la atiendo, ¿no?
-->
Algo así, no sé.
-->
O notificarle a alguien de que algo está fallando, ¿no?
-->
O sea, para eso te permite utilizar el mecanismo del
-->
Circuit Breaker los fallbacks, ¿no?
-->
Para que cuando, y hasta que se cayó usuario o se cayó
-->
producto, tú vas a poder hacer que el flujo continúe,
-->
¿no?
-->
Eso es lo que se le llama tolerancia a fallos, ¿vale?
-->
Entonces, no sé si con eso quedó un poquito más claro.
-->
La aplicación queda perfecto.
-->
Vale, vale.
-->
Y de todo esto, pues, más al ratito,
-->
creo que eso les decía bien en el día de mañana,
-->
la práctica ya completa.
-->
Se va a ir viendo cómo vamos a ir configurando todos estos
-->
y vamos a ir haciendo tolerancia a fallos,
-->
comunicación entre microservicios.
-->
Y vamos haciendo el tema del descubrimiento de servicios
-->
también, ¿va?
-->
Entonces, este, bueno, aquí es básicamente lo que ya
-->
fuimos hablando, solo que lo fuimos poniendo en uno por
-->
uno, lo que es Eureka, lo que es Ribón,
-->
lo que es el Fancline, lo que es Hystrix, ¿sale?
-->
Entonces, estos ya los vimos, ya los repasamos.
-->
Y, pues, bueno, esa es la parte de estos conceptos.
-->
Entonces, aquí viene el tema del ejemplo teórico,
-->
que básicamente es lo que decíamos sobre los
-->
microservicios de producto, usuario y pedidos,
-->
u órdenes, ¿va?
-->
Este, aquí vemos cómo cada uno de estos productos
-->
interactúan, que es básicamente el ejemplo que
-->
ahorita ya fuimos hablando, ¿no?
-->
El Config Server, el Config Bus, este,
-->
se configura y te permite hacer este
-->
almacenamiento de las configuraciones cada
-->
microservicios, básicamente es lo que fuimos describiendo,
-->
¿no?
-->
Se habla de cómo se ocupa el Config Bus,
-->
cómo lo ocupa cada microservicio,
-->
que en este caso decíamos que es Kafka,
-->
quien nos va a estar ayudando a hacer ese,
-->
esa propagación de cambios, ¿sí?
-->
Y para de esa forma automáticamente las
-->
actualizaciones van a surtir efecto en cada
-->
microservicio.
-->
Vamos a tener la parte de Eureka para el registro y
-->
descubrimiento de microservicios y facilite,
-->
pues, la comunicación entre ellos, ¿sí?
-->
Vamos a ocupar el tema de Ribon para lo del balanceo de
-->
carga, que básicamente es, mientras más tráfico vienen
-->
estos servicios, pues, se van a estar generando
-->
instancias y la distribución de ese carga,
-->
o sea, balanceo hacia cada una de ellas,
-->
las van a estar haciendo en automática, ¿va?
-->
Vamos a estar viendo lo que es el Faint Client,
-->
que es lo que, igual, ya habíamos hablado de cómo se
-->
va a implementar en este caso en el microservicio,
-->
perdón, en el microservicio de las órdenes para que se
-->
pueda comunicar con los productos y con los
-->
usuarios y el Hystrix nos va a estar ayudando en el
-->
tema del fallback, ¿no?
-->
De la tolerancia a fallos, de cuando algo ocurrió en
-->
alguno de estos clientes, en alguna de estas
-->
comunicaciones, entonces Hystrix nos va a estar
-->
ayudando con ese fallback, ¿va?
-->
Eso es básicamente lo que traemos en esta diapositiva,
-->
Syntos.
-->
Dale, entonces luego viene lo que es una descripción de
-->
Spring Boot, ¿sale?
-->
Entonces, por eso les hacía ahorita la pregunta de si
-->
conocían Spring Framework, lo que es Spring Boot,
-->
y bueno, creo que la mayoría ya lo hemos trabajando,
-->
ya lo hemos trabajado.
-->
Y bueno, Spring Boot es un proyecto de código abierto y
-->
es desarrollado por esta empresa que se llama Pivotal,
-->
que es la de la que ahorita ya compartí incluso aquí la
-->
página, ¿sí?
-->
Y nos facilita la creación de aplicaciones Java de
-->
manera rápida y sencilla.
-->
Proporciona una plataforma eficiente para construir
-->
microservicios, aplicaciones web y servicios
-->
restful, entre otros, ¿no?
-->
Spring Boot está diseñado para ser fácil de usar,
-->
reduciendo la complejidad de la configuración y la
-->
implementación, lo que permite a los desarrolladores
-->
centrarse en la lógica de no negocio y no en la
-->
infraestructura.
-->
Entonces, de todo esto igual, yo lo que subrayo es esta
-->
parte, porque Spring Boot, hablando de Spring Boot,
-->
en efecto su propósito es este, ¿no?
-->
Brindar o reducir, mejor dicho,
-->
la complejidad de la configuración y de la
-->
implementación.
-->
Entonces, eso nos ayuda a que nosotros podamos desarrollar
-->
de una forma más rápida.
-->
Para hablar de Spring Boot, antes me voy a centrar en lo
-->
que es Spring Framework también,
-->
como para poder tener el punto de comparativa.
-->
Cuando nosotros nos tocaba desarrollar aplicaciones con
-->
Spring Framework, ya sea que haya sido antes o todavía las
-->
hagamos, ¿quiénes lo llevamos a manejar?
-->
Spring Framework es un framework,
-->
vamos a decirlo tal vez entre comillas, complejo,
-->
porque tú tienes que hacer todas estas configuraciones
-->
e implementaciones de forma, pues vamos a decirlo,
-->
así manual, ¿no?
-->
Es decir, tú tienes que estar desarrollando muchos
-->
archivos de configuración, los XML, el mapeo de Vins,
-->
todo eso, ¿no?
-->
Que realmente, para una persona que va empezando,
-->
pues vamos a decirlo tal cual es,
-->
pues sí suele ser complejo, ¿no?
-->
Suele ser complejo el desarrollar este,
-->
porque a veces hasta como que pierdes el enfoque y dices,
-->
oye, pues yo quería programar lógica, ¿no?
-->
Yo quería hacer ciclos while, case, quería hacer if,
-->
y de repente me estás hablando que tengo que configurar
-->
Vins y no sé qué tanta cosa y mapear XML,
-->
de pronto como que se pierde un poquito, ¿no?
-->
Entonces, Spring Boot lo que dice es,
-->
OK, yo me voy a centrar en que te voy a ayudar en
-->
reducir toda esa configuración porque es necesaria,
-->
pero yo voy a reducirla y tú solamente te vas a encargar
-->
de mapear las cosas a conforme yo te las estoy pidiendo,
-->
ya sea que sea por una anotación,
-->
que agregues algún nombre muy en específico tal cual,
-->
entonces, eso es lo que ocupa Spring Boot
-->
para que las configuraciones se pueden hacer de forma
-->
automática.
-->
Y, bueno, así como trabaja Spring Boot,
-->
yo lo he visto en otros frameworks.
-->
Quienes también conozcan de esto saben que la mayoría
-->
de los frameworks trabajan así, ¿no?
-->
Trabajan más bien sobre configuración automática
-->
y te dejan desarrollar de forma más rápida.
-->
Entonces, bueno, los frameworks más modernos, ¿no?
-->
Porque muchos se quedan en esta línea de Spring
-->
Framework, que la verdad no está mal.
-->
Simplemente son enfoques diferentes, ¿no?
-->
Hay gente quien se siente muy cómodo configurando o
-->
desarrollando esto porque quiere tener un control muy
-->
en específico sobre todo lo que ocurre en el framework.
-->
Y hay quienes también optamos por decir, nada,
-->
yo nada más me dedico a desarrollo,
-->
hago caso de todas las mapeos en automático,
-->
todas las configuraciones.
-->
Y ya con eso, pues, que el framework se haga bolas, ¿no?
-->
Entonces, cualquier enfoque es útil, es práctico,
-->
es aceptado.
-->
Y, pero, básicamente, esa es la diferencia entre esos dos,
-->
¿no?
-->
Entre framework, Spring Framework y Spring Boot.
-->
La configuración que tú le inviertes a cada uno de ellos,
-->
¿va?
-->
Y que, bueno, Spring Boot realmente es un proyecto
-->
derivado de Spring Framework.
-->
Entonces, realmente, el mero mole,
-->
el proyecto estrella de Spring, sí, es Spring Framework, ¿no?
-->
Este es un framework más potente, el más robusto.
-->
Pero, bueno, Spring Boot es un framework que poco a poco
-->
ha ganado iniciativa con la gente, ¿no?
-->
Vamos a hacer aquí la pauta del pomodoro.
-->
Entonces, igual son 5 minutos.
-->
11 y 12.
-->
Nos volvemos a conectar, ¿les parece?
-->
Vamos a dejarlo 5 minutos y ahorita nos volvemos a ver.
-->
Bueno, bueno.
-->
¿Lo escuchan?
-->
Perfecto.
-->
Vale, vale, entonces vamos a continuar.
-->
Voy a poner el siguiente pomodoro.
-->
Listo, sale.
-->
Entonces, a ver, nos quedamos en esta parte.
-->
Ahí está, ya se quitó.
-->
Vale, entonces, estábamos viendo lo que es la diferencia
-->
entre Spring Framework y lo que es Spring Boot.
-->
Sale.
-->
Decíamos que Spring Framework es marco trabajo más extenso
-->
y proporciona una amplia gama de funcionalidades
-->
para el desarrollo de aplicaciones empresariales.
-->
Y en contraste, Spring Boot es una extensión de lo que es
-->
Spring Framework y se centra en la simplicidad.
-->
Y de esta forma, pues aceleramos el proceso de desarrollo
-->
con este concepto de configuración automática, ¿va?
-->
Entonces, este Spring Boot hace uso de Spring Framework,
-->
pero le proporciona características adicionales
-->
y un enfoque más simplificado para el desarrollo
-->
de aplicaciones ya.
-->
Entonces, eso es básicamente Spring Boot.
-->
Es un framework basado en Spring Framework.
-->
Pero, bueno, se centra más bien en configurar de forma automática
-->
siguiendo ciertas reglas.
-->
Y, pues, bueno, te permite enfocarte en desarrollar
-->
aplicaciones de forma al menos más rápida que Spring Framework.
-->
Entonces, aquí hay un pequeño ejemplo de cómo es
-->
una aplicación construida con Spring Framework.
-->
Y también vamos a ver esta misma aplicación construida,
-->
pero con Spring Boot, ¿va?
-->
Entonces, con Spring Framework nosotros estamos viendo
-->
que se desarrolla un controlador.
-->
Aquí es una clase que se llama Hello Controller,
-->
que no es más que tiene un...
-->
Es un get, ¿va? Tiene un path mapping que es un hello.
-->
Tú le pones este hello a la URL local
-->
y va a entrar aquí, ¿no?
-->
A este servicio, a este método, perdón.
-->
Y esto es lo que va a responder en el body,
-->
una cadena que dice hola desde Spring Framework, ¿va?
-->
Esta es la clase, digamos, controlador.
-->
Después de esa clase controlador,
-->
nosotros tenemos una clase de configuración, ¿sí?
-->
Que básicamente nos permite habilitar el funcionamiento
-->
de las bibliotecas del modelo vista controlador.
-->
Sale, hace un escaneo de paquetes
-->
que está bajo esta nomenclatura, como example,
-->
hereda de esta clase padre,
-->
que es WebMVC Configure Adapter.
-->
Hacemos un override de algunos de los métodos de acá
-->
que básicamente nos ayuda a resolver las vistas
-->
y hacemos todo este mapeo, ¿no?
-->
De dónde se van a encontrar, de qué tipo de archivos van a hacer.
-->
Es un archivo de configuración, yo creo, bastante leve, ¿no?
-->
Pero bueno, al final se crea.
-->
Y bueno, es esta parte.
-->
Después, déjame un segundito, ¿no, por favor?
-->
Listo, ya, una disculpa.
-->
Luego llegan bastantes mensajes y revisarlos.
-->
Entonces, les decía de la parte de la aplicación
-->
con Spring Framework, vemos ahí también
-->
que además de la clase controller,
-->
también estamos viendo clases de configuración
-->
que son del tipo XML, por ejemplo, en este caso.
-->
O sea, al final son clases que son
-->
adicionales a la lógica de negocio,
-->
de donde nada más tú desarrollas un controlador y ya.
-->
Pues bueno, eso es básicamente
-->
como que la forma en la que se desarrolla
-->
una aplicación con Spring Framework.
-->
Y luego aquí viene en esta dispositiva
-->
como que la aplicación de que hace cada cosa, ¿no?
-->
Tienes la clase controller.
-->
Tienes las dos clases de configuración.
-->
Aquí te dice que va haciendo cada una de las clases.
-->
Clásicamente son configuraciones
-->
para mapear los archivos JCP, son las vistas.
-->
Se utilizan este tipo de anotaciones también.
-->
Y bueno, el archivo web XML para el server dispatcher.
-->
Y bueno, esto al final también es
-->
configuración, ¿no?
-->
Es configuración adicional, por así decir, ¿no?
-->
Pues para que tú necesitas
-->
en el desarrollo de la aplicación, ¿no?
-->
Con Spring Framework.
-->
Entonces sí es un poquito
-->
de pasos más
-->
que solamente
-->
centrarte en un controlador, ¿no?
-->
Y ahora la misma aplicación construida,
-->
pero con el framework de Spring Boot,
-->
pues es esta, ¿no?
-->
Básicamente tú tienes el mismo controlador,
-->
¿sale?
-->
Lo anotas para que sea
-->
un REST controller en automático.
-->
Spring Boot te va a proveer de todas las configuraciones
-->
que hicimos manualmente.
-->
Las va a meter en automático.
-->
Simplemente te pide utilizar
-->
estas dos anotaciones.
-->
Y en una aplicación,
-->
bueno, declarar una clase
-->
que ocupe el método main.
-->
Sí, que se va a anotar con esta
-->
anotación, que es el Spring Boot Application.
-->
Y con eso
-->
tú ya vas a poder hacer
-->
que tu aplicación
-->
también levante.
-->
De hecho, aquí vemos en la descripción
-->
de que hace cada cosa. Igual tienes un
-->
fellow controller.
-->
A ver, permítanme, déjenme le bajo aquí tantito
-->
porque está muy alto.
-->
Tienes este
-->
fellow controller.
-->
También sigues teniendo las anotaciones.
-->
Este te define qué hace
-->
en cada método.
-->
Y pues bueno,
-->
de las cosas que son como importantes
-->
las fuimos poniendo en negritas.
-->
Aquí por ejemplo, para el
-->
caso de Spring Boot, la clase
-->
Maya PP es muy importante
-->
porque es la que obtiene esta
-->
anotación. Básicamente
-->
esta es la que nos permite hacer
-->
que, pues vamos a decirlo así,
-->
toda la magia de que se te
-->
configure todo de forma
-->
automática.
-->
De forma automática, sin que
-->
tú tengas que meter archivos
-->
adicionales de como los XML
-->
que vemos en el ejemplo de Spring
-->
Framework. Entonces, si nos
-->
vamos por el enfoque de Spring Boot,
-->
la misma aplicación se hace con dos clases.
-->
¿Viste? Solamente dos clases.
-->
Y la con
-->
Spring Framework, pues sí ocupas
-->
un poquito más.
-->
En un poquito
-->
mucho tema. Entonces,
-->
eso es como que una diferencia
-->
a nivel
-->
digamos, todavía también es teórico, pero
-->
se ve ya un poquito más bien código
-->
como sería la diferencia entre
-->
crear y utilizar un framework y otro.
-->
En este curso,
-->
pues vamos a estar ocupando lo que es
-->
Spring Boot.
-->
No nos vamos a preocupar más que por
-->
configurar todo en automática.
-->
Luego, viene el
-->
entorno de desarrollo
-->
y esto es lo que vamos a estar
-->
haciendo, digamos, ya en la parte
-->
práctica. Ya el tema
-->
teórico, ya a partir
-->
de aquí ya lo terminaríamos.
-->
Entonces, ya estaríamos sentándonos en la
-->
parte
-->
práctica.
-->
Como les decía al final del día de hoy,
-->
vamos a
-->
levantar
-->
los tres microservicios, que son el de
-->
usuario, producto
-->
y el de órdenes y vamos a
-->
estar haciendo un
-->
CRUD sobre cada uno de ellos.
-->
Entonces,
-->
para la configuración del entorno de
-->
desarrollo, ya
-->
ven que ya estamos todos aquí
-->
dentro de estas máquinas, ¿verdad?
-->
¿Alguien tuvo problemas en conectárselas?