Visit the Blockchain Fundamentos 1 course recordings page
WEBVTT
-->
¿Sí?
-->
Porque no me regreso.
-->
Ahí está.
-->
Sal.
-->
Entonces, bueno, ya tenemos el repositorio ahí abajo.
-->
OK.
-->
Ahora, ¿qué vamos a hacer?
-->
Vamos a revisar antes de abrir el código aquí en el
-->
repositorio, en la interfaz web, por así decirlo.
-->
Si tú te fijas, hay un archivo readme que se
-->
configura.
-->
Que, bueno, obviamente habla del proyecto y te da unas
-->
instrucciones.
-->
Te pone ahí unos instrucciones.
-->
Esas instrucciones son las que hay que seguir para que
-->
nosotros podamos bajar desde lo que es Docker Desktop el
-->
nodo de Ethereum.
-->
Nosotros ya lo tenemos configurado.
-->
Ya está creado.
-->
Porque si se fijan, aquí está.
-->
Pero yo voy a mostrar cómo es que se hace eso para que esta
-->
red de Ethereum se cree.
-->
Entonces, si yo no tuviera nada aquí,
-->
yo lo que tendría que hacer primero es ejecutar el comando
-->
1 que me dice que es Docker pool y esto de acá.
-->
Entonces, yo lo que haría es copiar este código,
-->
el número 1.
-->
Me voy a una terminal cualquiera en donde quieras,
-->
en la ruta que tú quieras.
-->
Y tú vas a poder ejecutar comandos Docker porque
-->
obviamente ya tienes Docker instalado.
-->
Entonces, al tener Docker, tú ya vas a poder ejecutar este
-->
tipo de comandos.
-->
A la C está este primer comando.
-->
Lo que se hace es que se va a bajar Docker,
-->
la imagen que se llama Ethereum de un repositorio
-->
central.
-->
Algo así como lo que estamos haciendo nosotros de
-->
GitHub hace Docker internamente.
-->
Se va a los repositorios de Docker que son comunes,
-->
por así decirlo.
-->
Son repositorios públicos, algunos, la mayoría.
-->
Y va y descarga la imagen, ¿va?
-->
Y esa imagen luego la va a convertir a un contenedor.
-->
Lo hace todo esto en automático Docker.
-->
Cuando el proceso de la imagen haya terminado de
-->
crearse, ¿sí?
-->
Incluso, déjame ver, yo creo que sería buena práctica
-->
si lo elimino.
-->
Solamente esto lo voy a hacer yo, ¿va?
-->
Lo voy a eliminar y lo voy a volver a crear desde cero.
-->
Entonces, ahí yo estoy eliminando el contenedor.
-->
Voy a eliminar también la imagen porque ya la había
-->
bajado.
-->
Haz de cuenta que lo voy a dejar como si no tuviera
-->
nada.
-->
Y los volúmenes también creo que se crearon.
-->
Ahí ya no hay nada.
-->
Perfecto.
-->
Entonces, si te fijas, ya está limpio, ¿no?
-->
No hay nada.
-->
Y lo que voy a hacer es seguir los pasos, pues,
-->
para que yo pueda bajarme ese nodo.
-->
Entonces, voy a crear este primer comando.
-->
Lo ejecuto aquí en mi terminal.
-->
Y al hacer esto, como yo tengo abierto el cliente de Docker,
-->
aquí me va a estar bajando la información.
-->
Ahí, si te fijas, está haciendo esta descarga.
-->
Y, bueno, ahí te dice que ya acabó.
-->
Y si tú te fijas, yo me voy aquí a las imágenes y ya
-->
tengo la imagen de Docker descargada.
-->
La pura imagen, ¿va?
-->
A partir de la imagen, yo puedo crear el contenedor.
-->
Entonces, para eso, yo voy a ejecutar el siguiente comando.
-->
Si te fijas, son comandos muy sencillos.
-->
Simplemente es prácticamente copiar y pegar.
-->
Sí.
-->
Yo aquí ejecuto mi siguiente comando.
-->
Nada más copio y pego.
-->
Y si te fijas, ahí va a estar haciendo también un proceso
-->
Docker.
-->
Sí.
-->
Y con eso, ahora yo voy a tener un contenedor ya activo,
-->
que si te fijas, tengo la imagen.
-->
Y tengo el contenedor.
-->
Aquí ya está.
-->
Vamos a revisar un poquito con detalle qué hace este
-->
comando de Docker.
-->
Entonces, lo voy a copiar.
-->
Y me lo voy a llevar a una interfaz un poquito más de
-->
para visualizar código.
-->
Les puse también ahí un paquete que se llama Sublime
-->
Text, que no es más que es un editor.
-->
Es como un notepad o eso, ¿no?
-->
Pero de código.
-->
Entonces, yo lo abro.
-->
Y voy a pegar este comando y voy a tratar de hacer un zoom.
-->
Así, mira, se hace un poquito más el zoom.
-->
¿Sale?
-->
Entonces, creo que con eso se ve un poquito mejor.
-->
Este comando lo que hace es ejecutar la imagen que
-->
encuentra, que es la de Terium, que ya bajamos.
-->
Bueno, de hecho, vamos a copiar los tres comandos
-->
que están aquí en el Ritme, ¿sí?
-->
Con el fin de poderlos ilustrar todos, ¿no?
-->
Entonces, el primer comando que se ejecutó fue este,
-->
el Docker Pull.
-->
Luego, hicimos el Docker Run.
-->
¿Sale?
-->
Y por último, hicimos este.
-->
Bueno, este nada más es como para ver los logs del
-->
nodo.
-->
Entonces, lo puedo ejecutar como para que lo vean.
-->
Aquí el nodo ya está corriendo.
-->
Si yo ejecuto esto, aquí yo voy a poder ver los logs
-->
que están dentro de este nodo, ¿va?
-->
Que ya vimos lo que es un nodo de Terium, ¿no?
-->
Bueno, vimos lo que es un nodo de blockchain, más bien.
-->
O sea, ahora estamos fungiendo como uno de esos pequeños
-->
nodos de esa cadena, ¿va?
-->
Entonces, las opciones que nosotros estamos poniendo en
-->
este comando, obviamente, aquí el Name,
-->
estoy ejecutándole un nombre a mi contenedor.
-->
Este nombre de Terium Node es el que tú puedes ver acá,
-->
¿no?
-->
En donde dice Name.
-->
Luego te dice que le digas en qué puerto va a correr.
-->
En este caso, yo le estoy diciendo que virtualmente o
-->
internamente el contenedor se ejecute en el puerto 8545 y
-->
en la máquina en donde está siendo alojado ese contenedor
-->
también tome el 8545.
-->
Entonces, yo ahorita el puerto en mi máquina de
-->
Windows tengo ya ocupado el 8545,
-->
porque obviamente tengo la instancia de este contenedor
-->
corriendo.
-->
De hecho, aquí me lo marca, ¿va?
-->
Eso es lo que estaría haciendo esa parte del comando.
-->
Y después, bueno, aquí te dice cómo tienes que estar,
-->
que es lo que hace cada uno de los flags que estamos
-->
activando.
-->
Por ejemplo, el flag HTTP lo que hace es habilitar un
-->
servidor HTTP del tipo RPC, ¿sí?
-->
La bandera DEV lo que hace es que está corriendo este nodo en
-->
modo de desarrollo.
-->
Esto es por lo que les decía que esto es una cuenta ficticia,
-->
No es una cuenta real.
-->
Entonces, las transacciones yo voy a poder hacerlas,
-->
pero obviamente esto no se va a publicar en la red pública
-->
de blockchain, ¿no?
-->
En la red de producción, por así decirlo, ¿no?
-->
La red, la red, este, funcional.
-->
Aquí también le estoy dictando una dirección HTTP,
-->
que obviamente este es el puerto local, el localhost.
-->
El puerto, que le estoy diciendo que está en el 8545.
-->
Y, bueno, todo esto que dice que es API,
-->
ednet, web3, personal, son las APIs que van a estar
-->
disponibles a través de este puerto, de este,
-->
perdón, de este contenedor.
-->
Esto porque las vamos a ocupar ahorita para interactuar
-->
con nuestro programa de Java que vamos a estar
-->
desarrollando, sobre todo la librería de web3, ¿va?
-->
Entonces, eso es básicamente lo que hace.
-->
Yo sé que ahorita suena un poquito raro,
-->
a lo mejor, para que ocupamos cada cosa.
-->
Pero, bueno, al final se necesita crear este comando y
-->
vamos a tener la imagen, ¿va?
-->
Otro comando que nos ayuda es este.
-->
Y este lo único que hace es monitorear la salud del nodo.
-->
Si tú te fijas, aquí a lo mejor lo ves en verde y te
-->
indica o te da un indicador de que está sano.
-->
Si estuviera en amarillo, hay un warning en naranjado.
-->
Creo que ahí ya tiene como un estado ya de problema, ¿no?
-->
Ah, bueno, aquí lo que es otra cosa.
-->
Pero el para verificar el estado es con un Docker PS.
-->
Creo que es un A.
-->
A ver, vamos a ver el flag.
-->
Sí, Docker PS guion A.
-->
Entonces, si yo ejecuto este comando,
-->
Docker PS guion A, lo que voy a hacer es ver cómo está,
-->
básicamente, el resumen de mi contenedor,
-->
que básicamente es lo que aquí también nos está listando.
-->
Ahí nos dice que el estatus es corriendo.
-->
Entonces, el nodo está listo para que yo ahorita lo pueda
-->
interactuar con él, ¿va?
-->
Y, bueno, ahí también incluso te pone ¿hace cuánto tiempo
-->
lleva de creado?
-->
Los puertos que ocupa, etcétera, etcétera, ¿no?
-->
Entonces, esto es básicamente la interfaz de Docker.
-->
Hasta ahorita no lo has visto nada más que Docker para crear
-->
un nodo de Ethereum, ¿va?
-->
Así de simple se creó.
-->
Entonces, tú con esto no estás casado a la máquina que
-->
tienes acá.
-->
O sea, tú el día de mañana que quieras completar el curso
-->
o volver a echarle un ojo, nada más tienes que tener
-->
acceso al repositorio, la dirección en particular,
-->
tu usuario y vas a poder seguir estas instrucciones.
-->
Con eso ya vas a tener instalado.
-->
Obviamente necesitas tener Docker Desktop instalado.
-->
Lo instalas y ya vas a poder ejecutar estos comandos, ¿va?
-->
¿Cómo se instala Docker Desktop?
-->
Lo ponemos nada más así rápido para que se vea en el
-->
video que he grabado.
-->
Pues nada más es meterte en la página, ¿no?
-->
Docker Desktop en cualquier navegador.
-->
Ahí te va a aparecer la opción.
-->
Y dependiendo de tu sistema operativo, pues te va a
-->
Y es como que tú ya estás, ¿no?
-->
Ya lo descargas, ya seas que ya sea que tengas un chip de
-->
Intel, un chip de Apple, un chip de Linux, bueno, un chip
-->
para Linux, porque son linux, etcétera, etcétera, ¿no?
-->
Ahí vas a tener este el la la opción de instalar,
-->
¿sale?
-->
Y eso es Docker.
-->
Y con eso pues te va a instalar esto.
-->
Esta interfaz que tú ves acá cuando la inicias, ¿sale?
-->
Entonces esa es la parte de Docker y así se está configurando la imagen oficial de Ethereum de forma local en un ambiente de desarrollo.
-->
¿Sale? ¿Alguien tiene alguna duda, alguna observación con esta parte?
-->
Si pudieran todos iniciar aquí el contenedor.
-->
Creo que ustedes, bueno, no tienen que seguir los comandos.
-->
Ustedes, como ya está creado, nada más le tienen que dar clic al botoncito que dice Play.
-->
Creo que es como un triangulito gris y al hacer eso ya se tiene que poner en verde.
-->
¿Alguien le dio adelante?
-->
Sí, te escuchamos.
-->
Exactamente.
-->
Exacto.
-->
Perfecto.
-->
Sí, exacto.
-->
Exacto.
-->
Entonces yo lo borré y lo volví a recrear para que se crea en el video y lo vean cómo se hace.
-->
Pero sí, ustedes, como ya lo tienen, nada más tienen que dar el Play y ya va a correr el nodo.
-->
¿Sale?
-->
A ver, voy a monitorear de forma rápida.
-->
Creo que sí, ya todos tenemos el nodo.
-->
Perfecto.
-->
Muy bien.
-->
OK.
-->
¿También tú, Fabiola? ¿Tienes el nodo corriendo?
-->
Ah, sí, ya lo vi.
-->
Perfecto.
-->
Listo.
-->
Bien.
-->
Bueno, entonces ya que tenemos el nodo de Ethereum local, ahora sí, voy a abrir el código para que veamos lo que hace el programa,
-->
que básicamente lo que hace este programa es conectarse a esta red, a este nodo de Ethereum,
-->
simulando como si yo me hiciera una conexión a una red blockchain pública.
-->
Obviamente, pues aquí la tenemos de forma local.
-->
Entonces, para eso vamos a abrir el código que bajamos del repositorio.
-->
Y para eso yo lo voy a abrir con un IDE en un entorno de desarrollo que se llama Intelli8.
-->
No sé si quienes han trabajado con Java o programado conocen este IDE.
-->
Pero bueno, lo voy a abrir como administrador.
-->
Y si te fijas, pues es la versión community para que no haya temas ahí de licencias y demás.
-->
Entonces, nada que ver con una edición de pago.
-->
Estoy de acuerdo.
-->
Pero la verdad es que la community está bastante robusta para lo que vamos a ocupar.
-->
Entonces, ahí vamos a esperar que abra.
-->
La verdad es que sí estamos teniendo problemas por lo de que nos bajaron la memoria.
-->
No me gustó que hicieran eso.
-->
Porque esto arrancaba un poquito más rápido.
-->
De por sí ya era lento con toda la capacidad.
-->
Arrancaba un poco más rápido.
-->
Entonces, les pego una disculpa porque nos va a costar un poquito de paciencia que avance esto.
-->
Pero bueno, ya que levanta el IDE, van a ver esta interfaz.
-->
Y aquí en la carpeta que dice Open, ustedes van a poder abrir un proyecto.
-->
Ese proyecto, obviamente, está en la carpeta que ya habíamos dicho.
-->
En C, Users, Noble, Prog.
-->
Se van a ir a Repositorios y van a ver, en este caso, lo único que tenemos que es Ethereum Local.
-->
Va, yo lo abro.
-->
Le voy a dar ahí.
-->
Lo selecciono, le doy OK.
-->
Y se me va a abrir el proyecto.
-->
Ahí se va a tardar un poquito.
-->
Va a estar pensando.
-->
Y pues básicamente lo primero que va a estar haciendo es leyendo todas las configuraciones que tiene en el archivo de configuración.
-->
En un archivo PUM.
-->
Recuerdo que cuando nos presentamos, pues no muchos se dedican al tema de la programación activamente.
-->
Por eso me voy a detener un poquito en dar una embarrada.
-->
Como para que no haya...
-->
Todos estemos en el mismo canal.
-->
Tampoco es como que necesiten comprenderlo al ciento por ciento.
-->
Pero sí nada más como para ver qué está haciendo el programa.
-->
Entonces ahí da un problema.
-->
Desde la otra vez también me dio no sé por qué.
-->
Creo que es un problema ahí con el IDE.
-->
Ese problema no hay que hacerle caso.
-->
Nada más limpienlo.
-->
Hay un botón de basura.
-->
Lo pueden apretar.
-->
Un botecito.
-->
Y no pasa nada.
-->
Para que se quite ese mensaje.
-->
Ahí está.
-->
Creo que me salí.
-->
Entonces el IDE empieza a hacer su trabajo de descargar librerías y demás.
-->
Y ahí lo vamos a dejar que piense un poquito.
-->
Como ustedes tienen una réplica de mi máquina, creo que ya también a ustedes les bajo las librerías.
-->
Pero bueno, de todos modos, le vamos a dar ahí un tiempo para que piense.
-->
En lo que hacemos eso, necesitamos nosotros hacer algo muy importante.
-->
Un cambio.
-->
Tenemos que cambiarnos de rama.
-->
¿Se acuerdan que les comentaba que yo voy a...
-->
La rama main no hay que tomarla en cuenta.
-->
Eso de las ramas, IntelliJ lo muestra acá.
-->
¿Va?
-->
Entonces esta rama main, les decía que no la vamos a tocar.
-->
La rama de develop la voy a ocupar yo.
-->
Para hacer la demostración.
-->
Y ustedes van a estar ocupando la rama que se llama feature blockchain.
-->
¿Va?
-->
Entonces, ¿cómo nos vamos a cambiar de rama?
-->
Se van a hacer, por favor...
-->
Me trae.
-->
Nos vamos a meter por favor aquí al navegador.
-->
¿Sí?
-->
De donde estamos en la cuenta de github.
-->
Y aquí donde está el selector de ramas.
-->
Ayúdenme a picarle.
-->
Y...
-->
Ah, bueno.
-->
Es más fácil la cámara.
-->
Donde dice tres branches.
-->
Píquenle.
-->
Y ahí los va a llevar acá.
-->
Una vez que estén aquí en esta página, en esta interfaz.
-->
Va a aparecer esta branch que dice feature blockchain.
-->
Hay que darle otra vez aquí en los cuadrados que aparecen ahí.
-->
Y al darle te va a decir que ya está copiado.
-->
¿Va?
-->
¿Para qué es eso?
-->
Para que, bueno, yo pueda hacer un comando en github que se llama checkout.
-->
Se los voy a ir escribiendo.
-->
Ah, bueno.
-->
Aquí tengo que estar dentro del repositorio.
-->
Entonces, le meto a Ethereum local.
-->
Y una vez que estoy dentro del repositorio,
-->
yo voy a ejecutar una serie de comandos.
-->
El primero de ellos va a ser git status.
-->
Cuando yo haga ese status,
-->
si te fijas, aquí me dicen qué rama estoy.
-->
Y aquí me dice que estoy en la rama main.
-->
Que es la misma que IntelliJ me estaba reportando.
-->
Que me dice que estoy en main.
-->
Pero la idea es que yo no tengo que estar en main.
-->
Yo tengo que estar en la rama que me hicieron,
-->
que se llama feature blockchain.
-->
Entonces para eso voy a ejecutar otro comando que se llama git checkout.
-->
Y voy a pegar el nombre de la rama que yo copí.
-->
¿Va?
-->
Entonces repito, el comando es git espacio checkout.
-->
Otro espacio y pego el nombre de la rama.
-->
Y al hacer eso y darle enter,
-->
me va a aparecer un mensaje en el prompt
-->
que me dice que ya te cambiaste a una nueva rama.
-->
Y la rama estás acá.
-->
Para comprobarlo, otra vez yo puedo ejecutar el comando git status.
-->
Y ahora la rama ya me dice que es feature blockchain.
-->
Ya no es la rama main.
-->
Eso es lo que ustedes, por favor, ayudenme.
-->
Tienen que hacer para que el desarrollo no se vea afectado.
-->
Y cuando ustedes entren aquí al IDE otra vez,
-->
tienen que ver aquí en el selector de ramas,
-->
esta rama que se llama feature blockchain.
-->
¿Va?
-->
Ahorita les explico por qué ustedes tienen que estar en esta rama.
-->
Básicamente porque aquí está vacío el proyecto.
-->
Y la idea es que lo vayan complementando.
-->
Y bueno, eso es lo que ustedes tienen que hacer.
-->
¿Tienen alguna duda con esto de cómo cambiarse de rama?
-->
Voy a ir monitoreando y si alguien tiene broncas,
-->
me avisa y le puedo ir ayudando.
-->
¿Si lo lograste tú, Vanessa?
-->
Sí.
-->
Creo que ahí está.
-->
Perfecto.
-->
Ya estés en la rama.
-->
Fabiola también.
-->
De hecho, algunos ocupan la clínica de Intelli8.
-->
Está perfecto.
-->
Está muy bien.
-->
Va, pues sí, creo que...
-->
Ah, listo.
-->
A ver, voy contigo, Mau.
-->
Entonces, a ver.
-->
¿Puedes meterte a donde está la línea de comando, por favor?
-->
El CMD.
-->
Excelente, ahí mero.
-->
Ahora, ahí hay que meternos al repositorio de Ethereum.
-->
Entonces presiona el comando CD, espacio.
-->
Y si tú pones una E, nada más la pura E,
-->
y pones tabulador, te va a completar la carpeta.
-->
Ahí estás.
-->
Entonces dale enter.
-->
Y ya que estés ahí adentro,
-->
ejecuta el comando de git, espacio.
-->
Git, G-I-T.
-->
Espacio.
-->
Y escribe la palabra status.
-->
Ah, sin la I.
-->
Ahí se me fue.
-->
Status.
-->
Correcto.
-->
Exacto.
-->
Dale enter, porfa.
-->
Y al hacer eso, te fijas que ahí te dice que estás en la rama mail.
-->
Entonces hay que cambiarnos.
-->
Para eso hay que poner git, espacio, checkout.
-->
Git, checkout.
-->
Puedes ponerlo junto a la palabra.
-->
Checkout va junto.
-->
Está bien escrito, pero va junto.
-->
OK.
-->
Espacio.
-->
Ahora, vamos a cambiarnos a la rama que está creada.
-->
Para eso hay que irnos al navegador, por favor.
-->
Correcto.
-->
Y ahí adentro donde dice main,
-->
hay un selector de ramas.
-->
Y al lado dice tres branches.
-->
Pícale donde dice tres branches.
-->
Al ladito del selector de main, dice main.
-->
Y al ladito dice tres branches.
-->
No, no, no.
-->
Más arribita.
-->
Mira, más arribita.
-->
Si te fijas, dice main.
-->
Y es como un drop down list.
-->
Ándale.
-->
Correcto.
-->
Correcto.
-->
Y ahí, si te fijas, está donde dice active branch.
-->
Está feature blockchain.
-->
Y al lado hay otros dos cuadritos.
-->
Presiona esos dos cuadritos para que te copie el nombre.
-->
Donde está en azul, como en el azulito dice active branches.
-->
No.
-->
Abajito.
-->
Abajo, abajo.
-->
Ahí, ándale.
-->
Al lado, a la derecha, hay dos cuadros.
-->
Pícale esos dos cuadros.
-->
Perfecto.
-->
Ahí mero.
-->
Ahora, otra vez métete, porfa, al, al, al, a la terminal.
-->
Ajá.
-->
Y dale pegar.
-->
Ahí copiaste el nombre de la rama.
-->
Perfecto.
-->
Dale enter.
-->
Y con eso ya te hizo el cambio.
-->
Ahí está.
-->
Ya estás cambiado esa rama.
-->
Ahora, si tú te vas a IntelliJ y te fijas en, en el proyecto,
-->
ya hasta arriba, hasta arriba, donde se ve como anaranjado,
-->
como franja.
-->
Ahí ya estás en la rama apuntando.
-->
Eso está bien.
-->
Para que te borre ese error de rojo que salió de internal error,
-->
no sé qué.
-->
A la derecha, todo hasta la derecha,
-->
hay un botecito de basura.
-->
Ahí le puedes picar y ya se va a borrar eso.
-->
Se limpia la consola.
-->
No, arribita donde estabas de hecho.
-->
Ahí, ese mero.
-->
Ese.
-->
Sí, está medio difícil.
-->
Perfecto.
-->
Ya estás en la rama.
-->
OK.
-->
Bueno.
-->
No.
-->
Gracias a ti.
-->
Ahí está perfecto.
-->
OK.
-->
Entonces ya todos estamos en la rama.
-->
Y como les decía, pues básicamente es para que ustedes puedan primero ver.
-->
Yo me voy a regresar a la rama de DevLog,
-->
pero solo yo para que yo pueda, este,
-->
mostrar cómo funciona el programa que creamos.
-->
Sale.
-->
Bueno, el ejercicio.
-->
Y pues ustedes sí tienen que estar en la rama de Feature Blockchain
-->
para que hagan la práctica.
-->
Entonces, bueno.
-->
Vamos a continuar.
-->
Todavía quedan cuatro minutos.
-->
Antes de que te suene la alarma del pomodoro.
-->
Ahorita tocaría el pomodoro largo.
-->
Va?
-->
Entonces, este.
-->
Vamos a empezar.
-->
Miren.
-->
Este proyecto les voy a dar así como una primera.
-->
Antes de empezar a revisar todo el código.
-->
Parte por parte.
-->
Vamos a entender un poquito el framework que se está ocupando.
-->
Que digo, no es la intención explicarlo a detalle.
-->
Espérame.
-->
Y está entrando alguien.
-->
Admitir.
-->
Listo.
-->
No es la intención explicarlo en detalle,
-->
pero sí voy a hacer mención un poquito.
-->
Y yo sé que no es parte del temario, pero.
-->
Este.
-->
Nada más.
-->
Una embarrada.
-->
Spring Boot.
-->
Entonces, el Spring Boot es un framework que se basa en Java.
-->
Prácticamente nos permite construir aplicaciones de una forma.
-->
Muy rápida en comparación a su otro.
-->
A su otro.
-->
Cómo decirlo?
-->
Derivado que se llama Spring Framework.
-->
De hecho, lo dije al revés.
-->
Spring Boot es un derivado de Spring Framework.
-->
Spring Framework es un framework.
-->
Es el producto estrella.
-->
Digamos de estos.
-->
De Spring de estos desarrolladores que esta empresa se llama Pivotal.
-->
Entonces, el producto estrella es Framework.
-->
Spring Framework.
-->
Y uno de sus derivados es Spring Boot.
-->
Nada más como para que se lo lleven como brebaje cultural.
-->
Tal vez un resumen.
-->
Dos enunciados.
-->
Spring Boot.
-->
Es un framework que crea.
-->
Aplicaciones de forma más rápida que Spring Framework.
-->
Porque se basa.
-->
Meramente en lo que es la configuración.
-->
Eso es como que su eslogan.
-->
Tú te vas a dedicar.
-->
Te vas a encargar más bien de hacer.
-->
O de llevar buenas prácticas de configuración.
-->
Y el framework lo va a tomar todo en automático.
-->
Y lo va a desarrollar por eso de una forma más rápida.
-->
Si yo lo hiciera de forma manual con Spring Framework.
-->
Yo tengo más control sobre todo y demás.
-->
Pero la verdad es que sí es cierto que Spring Framework es entre comillas.
-->
Yo lo digo así porque realmente es.
-->
Es mero concepto.
-->
Pero es más complicado.
-->
Es un poco más complicada la curva de aprendizaje.
-->
Y eso es precisamente porque hay que configurar muchas cosas.
-->
Entonces.
-->
Eso es como la principal diferencia.
-->
Nosotros en este caso vamos a estar ocupando.
-->
Spring Boot.
-->
Sale.
-->
Vamos a estar ocupando Spring Boot.
-->
Basado en Java.
-->
La versión de Java que vamos a estar ocupando.
-->
Es la versión de Java 11.
-->
Esto es básicamente porque.
-->
Es una.
-->
Versión muy robusta.
-->
Muy comercial.
-->
Además.
-->
Y muy estable.
-->
Sobre todo es la palabra que buscaba.
-->
Estable.
-->
Conforme a las versiones de Ethereum.
-->
Que estamos manejando.
-->
Entonces.
-->
Si bien es cierto que Java 17.
-->
Java 20.
-->
Los Javas que hay ahorita.
-->
También se pueden conectar.
-->
Para mí se me hizo más estable.
-->
Manejarlo con una versión.
-->
Comercial.
-->
Y una versión que vas a encontrar más en la industria.
-->
Java 11.
-->
Para este caso.
-->
De la.
-->
De los Blockchains.
-->
Va.
-->
Entonces.
-->
Esta es la parte de Spring Boot.
-->
Y Spring Boot.
-->
Tiene un proyecto.
-->
Un proyecto web.
-->
Sí.
-->
Que se llama.
-->
Spring Initializer.
-->
Que voy a entrar.
-->
Y es lo último que vamos a ver.
-->
Porque ya va a sonar la alarma.
-->
Spring Initializer.
-->
Ahorita vamos a entrar más en detalle.
-->
Pero este proyecto web.
-->
O esta página.
-->
Esta interfaz.
-->
Lo que nos va a permitir.
-->
Es este.
-->
Crear proyectos.
-->
O armar proyectos.
-->
Con una configuración por default.
-->
Por medio de esta interfaz gráfica.
-->
Ahorita vamos a estar.
-->
Definiendo este proyecto.
-->
Que ya descargamos.
-->
Lo vamos a ver.
-->
Cómo se mapea.
-->
Con las configuraciones.
-->
Que aquí vamos a estar dando de alto.
-->
Y.
-->
Cuando esto se genere.
-->
Se puede descargar.
-->
Y vamos a ver.
-->
Cómo se creó ese proyecto.
-->
Para que no nada más.
-->
Se queden con que.
-->
Yo les di esto de la nada.
-->
Va.
-->
Vamos a ver.
-->
Cómo se.
-->
Se desarrolló.
-->
Más bien.
-->
Cómo se configuró.
-->
Por medio de esta herramienta.
-->
Sale.
-->
Entonces.
-->
Ahí está sonando.
-->
La alarma.
-->
Vamos a tomar.
-->
Ahorita.
-->
El pomodoro.
-->
De los.
-->
Veinticinco minutos.
-->
Entonces.
-->
Porfa.
-->
Doce y veinticinco.
-->
Nos volvemos a.
-->
A conectar.
-->
Este.
-->
Y.
-->
Después de eso.
-->
Pues ya.
-->
Continuamos con la parte del ejercicio.
-->
Va.
-->
Nos llevamos.
-->
La siguiente práctica.
-->
No sé si hay alguna duda.
-->
Antes de irnos al.
-->
Al pomodoro.
-->
O algún comentario.
-->
O algo que quieran.
-->
Aportar.
-->
De este.
-->
De este tema.
-->
De las.
-->
Doce y veinticinco.
-->
Veinticinco minutos.
-->
Vamos a tomar.
-->
Va.
-->
Perfecto.
-->
Bien.
-->
Entonces.
-->
Si no hay alguna.
-->
Duda.
-->
O observación.
-->
Nos.
-->
Nos.
-->
Tomamos el pomodoro.
-->
Y ahorita.
-->
Regresamos.
-->
Va.
-->
A dejar de compartir.
-->
Y ahorita nos volvemos.
-->
Y.
-->
Y.
-->
Y.
-->
Y.