YT YouTube2Text

YouTube2Text → Transcripts → Spring Security | Implementando Spring Security + JWT

Spring Security | Implementando Spring Security + JWT — Transcript

by JAAX · 18,399 words · 2,854 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00qué tal gente de YouTube Sean
0:01bienvenidos de esta tercera fase del
0:02curso de desarrollo web con Spring Boot
0:04Sí yo sé que nos hemos demorado un
0:06poquito sacando esta tercera fase Pero
0:08bueno cuestión de temas personales
0:10proyectos paralelos como pueden ver pues
0:12se cambió de lugar de grabación etcétera
0:15Pero no se preocupen porque esta tercera
0:17fase viene actualizada Pues con
0:19conocimientos de Sprint Security y Jason
0:22web token que Considero que van a ser un
0:24buen Punto de partida para la gente que
0:25está aprendiendo de Spring Boot es un
0:29muy buen conocimiento que ustedes van a
0:30Añadir a su stack sobre Cómo agregar
0:32seguridad es a sus también antes que
0:35nada pues me gustaría agradecerles a las
0:38personas que han estado suscribiéndose
0:39comentando dejando un like compartiendo
0:42este vídeo porque de esa forma nos están
0:43apoyando muchísimo ya que el algoritmo
0:45de YouTube nos va a ir recomendando
0:47mucho más listo entonces sin más
0:50enrollarme podemos pasar ya ahora sí al
0:52desarrollo e implementación de Spring
0:54Security con Jason web token Así que
0:56vamos allá
0:58[Música]
1:08Bueno muy bien Ahora sí sin más
1:10dilaciones Vamos a entrar en materia
1:12Pero antes de empezar a hacer el
1:15desarrollo la implementación de Spring
1:18Security como un Jason web token me
1:20gustaría matizar y que entiendan que es
1:22un Jason web token un Jason web token en
1:25simples palabras es un estándar que nos
1:27permite a nosotros generar tokens bajo
1:29pues la estructura de un Jason Ok nada
1:32más ahora este tipo de Jason
1:36viene conformado de la siguiente manera
1:38no este tipo de Jason web token como
1:40pueden ver aquí Bueno yo utilizo esta
1:43página es muy útil por si quieren ver
1:45cómo está estructurado los tokens que
1:46ustedes generen se llama jw.io aquí
1:50nosotros podemos ver por ejemplo un
1:52token Ok Recuerden que este token está
1:55codificado en base 64 Ok por lo que de
1:59cierta forma nos permite tener este la
2:01información segura No se ve encriptada
2:03Ahora este token consta de como mencioné
2:06solamente de tres partes no la primera
2:09es el header Ok el header contiene
2:11información sobre el tipo de algoritmo
2:12que se está utilizando para para la
2:16creación de este token que en este caso
2:17en este caso es hs 256 y el tipo de
2:23token que es como pueden ver es un Jason
2:25webdock Ok entonces toda esta
2:27información como pueden ver está
2:29codificada en esta parte de aquí que es
2:31en rojo se separa por un punto y la
2:34segunda parte que nos encontramos está
2:36en morado es el payload O la información
2:38o también conocida como la carga útil
2:41del Jason web token que tiene esta parte
2:45del del token básicamente contiene la
2:48información
2:50que nosotros queremos enviar para por
2:53ejemplo en este caso autenticarnos y que
2:55se nos autorice acceder a un recurso a
2:58nuestra Api resple no Recuerden que
3:00estamos agregando seguridades Entonces
3:01ya no Simplemente voy a realizar por
3:04ejemplo un get un post
3:06simplemente consumiendo una URL sino que
3:09también tengo que identificarme para ver
3:11si es que yo tengo los permisos para
3:13acceder a ese tipo de recursos no
3:15entonces Generalmente en el Pilot se
3:18envía esta información Como por ejemplo
3:19puede ser el usuario no Y en este token
3:22de ejemplo nosotros podemos ver que pues
3:25aquí tenemos el nombre ok el nombre en
3:28este caso del usuario que está
3:30codificado en este token y también
3:33podemos ver la fecha en la que se generó
3:36este token esta parte es muy importante
3:38porque aquí nosotros podemos
3:39configurarlo a nuestra manera para darle
3:41incluso hasta una fecha de expiración a
3:44nuestro token por ejemplo decirle sabes
3:46que yo quiero que este token dentro de
3:4810 minutos ya sea caduco entonces si es
3:50que vuelven a utilizar este token pasado
3:52los 10 minutos ya no puedes acceder a
3:54ese recurso y necesitas volver a
3:56autenticarte y que te autoricen acceder
3:58a un recurso OK Pero eso lo vamos a ver
4:00más adelante no nos aceleremos y
4:02finalmente la última parte que viene
4:05contenido en el token es la firma no en
4:09como podemos ver aquí está en chat 256 y
4:12la forma de codificación es en base 64
4:14Ok y el secreto que básicamente pues es
4:19la clave secreta de nuestro servidor que
4:22nosotros estamos configurando para que
4:25se genere esto qué es lo que nos permite
4:27a nosotros validar que el token sea
4:29auténtico no que haya sido generado por
4:32el mismo servidor y así proteger nuestra
4:34información muy bien una vez que hemos
4:37matizado la estructura de lo que es un
4:39Jason web token me gustaría pues que
4:40ustedes vean Cómo funciona el mecanismo
4:42no el flujo de nosotros implementarios
4:45Security común Jason webdock funciona
4:48de la siguiente manera Ok Generalmente
4:51tenemos un cliente no que puede que como
4:54mencioné puede ser un cliente web o
4:56simplemente una petición desde un
4:57navegador lo que sea pero tenemos un
4:59cliente que nos va a enviar una petición
5:01http ya antes mencionada en otras partes
5:04del curso que puede ser get post o
5:07cualquier tipo de actividad que queramos
5:09realizar dentro de nuestra aplicación
5:12nuestro backen recibe esta petición http
5:15Ok y lo primero que se ejecuta siempre
5:18va a ejecutarse el Jason web token
5:22autentication filter que es uno que como
5:24su mismo nombre indica es un filtro de
5:26autenticación que va a validar si el
5:29Jason web token me lo estás enviando si
5:32no me lo estás enviando Okay entonces
5:34como pueden ver cuando se envía la
5:37petición http Yo ya no estoy simplemente
5:39consumiendo una URL de mi backend sino
5:43que también tengo que identificarme para
5:45ver si es que estoy autorizado a
5:47utilizar esa URL entonces junto con la
5:50petición http También nosotros envíe el
5:53cliente enviaría un token similar a este
5:56para identificarse entonces llega a este
5:59filtro de autenticación ese toque y esto
6:02me ayuda primero a verificar si es que
6:06se toquen es válido o no Ok entonces
6:09como pueden ver el flujo arranca con el
6:12filtro autenticación y por ejemplo yo
6:15saco de ese token el usuario que tú me
6:18estás mandando No es cierto en este caso
6:19sería John doe póngale de ejemplo no
6:22Entonces qué es lo que primero pasa que
6:24yo utilizo el servicio de detalles de
6:27usuario Ok y este servicio lo que me
6:30permite a mí es ir a buscar si es que
6:32ese usuario existe en base de datos es
6:34decir si está registrado ya OK entonces
6:38me dice sabes que
6:41me retorna ese usuario Ok y el filtro
6:45valida Ok si ya tiene la respuesta
6:47validada de si ese usuario existe o no
6:49En caso de que no existiera lo que nos
6:52devuelve es un status 403 forbidden que
6:55es muy conocido que es un estatus que
6:57nos está indicando que no nos autoriza a
6:59utilizar un recurso a acceder a un
7:01recurso no Entonces nos dice el usuario
7:04no existe otra forma también de la que
7:06funciona este filtro es en caso de que
7:08tú consumas este esta URL no por ejemplo
7:11envíes un get pero no no le envías
7:13ningún token también nos va a retornar
7:15un estatus 403 indicando que no hay
7:18token entonces pues obviamente no no me
7:20estás dando tu credencial no te estás
7:23identificando para acceder a este
7:24recurso Ok Muy bien esto En caso de que
7:27el token no exista o de que el usuario
7:28no exista no una vez que el filtro dice
7:31sabes qué el usuario sí existe y me
7:35estás enviando un token entramos en un
7:38proceso conocido como la validación del
7:40Jason web token en este proceso Aquí sí
7:43se verifica que el token que tú me estés
7:45enviando sea auténtico que haya sido
7:48generado por el mismo servidor para que
7:50te permita seguir accediendo al recurso
7:52en caso de que este token sea inválido
7:55lo que pasa a continuación es que te
7:57devuelve de nuevo un estatus 403
8:00indicándote que el toque más válido Ok
8:03entonces Vamos a ponernos ahora en el
8:05escenario de que sabes qué existe existe
8:09el usuario
8:10me envías un token tu token se valida y
8:14es un toque en auténtico Entonces se
8:18actualiza algo conocido como El Security
8:20context holder Ok este contexto de
8:24seguridad básicamente me indica que el
8:27usuario efectivamente está auténticado
8:30porque ha pasado el filtro de
8:32autenticación del del Jason web token y
8:35aparte de eso también
8:36pasó la validación de Jason web token
8:39Entonces se actualiza este contexto no
8:41cabe recalcar que en cada petición
8:43entonces en cada petición Yo ya voy a
8:46poder acceder a este recurso Ok y una
8:50vez que se actualiza este contexto lo
8:52que va a hacer es Acceder al disparchad
8:55server servillet que no es más que el
8:58elemento del tomcat que decide Cuál
9:00controlador es el que tú quieres
9:01utilizar no O sea si por ejemplo tú
9:03envías un get a Api usuarios entonces
9:05pues del dispatcher identifica el
9:07controlador que estás queriendo utilizar
9:09te deja acceder al controlador y te
9:11devuelve del documento en formato Jason
9:14con información que tú estás queriendo
9:15acceder o realizando la performance que
9:18tú necesitas que puede ser un pud o un
9:20delito o un post no Ok entonces
9:24básicamente Esta es la forma en la que
9:27funciona pero recuerden muy importante
9:29siempre el primer elemento que se lanza
9:32en este flujo va a ser el filtro de
9:34autenticación OK Siempre voy a verificar
9:37que me mandes un Jason web token Y que
9:39aparte de eso existe el usuario que en
9:41ese Jason tú me estás tú me estás
9:43mandando en base de datos ya
9:46bueno algo que cabe recalcar Y esto es
9:48una nota mental que deberían hacérselo
9:50Es que este tipo de filtros es son
9:52conocidos Como One request filter OK
9:55Siempre se lanza en cada petición que el
9:58cliente nos está enviando al servidor Ok
10:00Muy bien Ahora sí una vez entendido esto
10:04el contexto como es la estructura de un
10:07Jason web token como es el flujo Ahora
10:09sí podemos pasar a la implementación
10:14muy bien entonces una vez visto la parte
10:17teórica bueno el contexto de lo que se
10:20va a realizar en esta fase del curso
10:22empecemos Ahora sí a levantar nuestro
10:25proyecto este proceso ya lo realicé Pues
10:27en la primera fase les dejo por aquí el
10:29link si es que no han visto la primera
10:30fase del curso sin embargo pues me
10:33pareció pertinente
10:35continuar este esta fase del curso
10:38haciéndolo todo desde cero muy bien
10:40entonces para ello Pues bueno nos
10:43encontramos en la plataforma en la
10:45herramienta Sprint inicial izzer de
10:47Spring y lo que vamos a hacer es empezar
10:49a configurar nuestro proyecto como ya es
10:52conocido vamos a trabajar con Maiden con
10:54formato xml también vamos a utilizar
10:57Java Ok la versión de Sprint a este
11:00momento pues la estable el último
11:02Release lanzado es del 3.1.1 OK Vamos a
11:07dejarla en esa versión vamos a cambiar
11:09el grupo Vamos a ponerle jacks aquí Ok
11:12perfecto y el artefacto vamos a poner
11:15como Spring Security
11:19sí déjamelo así como
11:22Ok perfecto descripción sería fase 3 del
11:26curso de Sprint Security con
11:31jwt que en este caso son los Jason web
11:34tokens Ok perfecto
11:36vamos a dejar en la versión 17 de Java
11:39que es la más estable bueno fue lanzada
11:41hace un par de meses igual Entonces
11:43vamos a dejarla con esa con esa versión
11:47de Java y bueno Cuáles van a ser las
11:49dependencias que vamos a utilizar
11:51inicialmente simplemente vamos a
11:53utilizar las siguientes la primera es
11:57Spring web OK Para desarrollo web vamos
12:00a utilizar el driver de postres también
12:03vamos a utilizar los Dead Tools de
12:06Sprint vamos a utilizar longbook OK
12:08recuerden que no nos ayuda a nosotros a
12:11mantener un código más limpio y varias
12:13anotaciones bastante útiles en el
12:15desarrollo
12:16perfecto y también Spring Data jpa para
12:20persistencia a la base de datos perfecto
12:23por el momento voy a Añadir estas
12:25dependencias ustedes se preguntarán
12:26Bueno dónde está Spring Security starter
12:29o las dependencias de los Jason web
12:30tokens no se apresuren ya vamos a ir más
12:33adelante añadiendo las dependencias
12:34conforme vayamos necesitando ok
12:36Muy bien Entonces vamos a ver una Vamos
12:39a darle una ojeada más pues a nuestro
12:41proyecto como pueden ver versión 3.1.1
12:44de Sprint los drivers longboard tenemos
12:47starter test perfecto formato xml de pom
12:51muy bien Vamos a cerrar y vamos a
12:53proceder a generar nuestro proyecto ya
12:55se ha descargado nuestro proyecto y
12:57ahora vamos a abrirlo con intelligent
13:01perfecto ya hemos abierto nuestro
13:02proyecto con intelligible como pueden
13:06ver pues ya se están haciendo bueno
13:08descargando las dependencias desde el
13:10repositorio de Maiden Ok entonces pues
13:13bueno ya hemos abierto vamos a ver cómo
13:16está la estructura de nuestro proyecto
13:18como pueden ver aquí está pues la
13:19carpeta src y todo mientras está
13:21haciendo el buil del proyecto Ok
13:23entonces lo que tenemos que hacer a
13:25continuación es esperar que se
13:27sincronicen todas las dependencias
13:28revisamos que esté todo correcto aquí de
13:31una vez en nuestro archivo ML perfecto
13:33el nombre Sprint Security fase 3 del
13:36curso de Spring Security con Jason web
13:38tokens muy bien perfecto entonces bueno
13:41Esto dependiendo de la conexión que
13:43ustedes tengan internet y al ir
13:44descargando las dependencias y se
13:46actualizará nuestro proyecto Ok entonces
13:50vamos a pegar un pequeño corte y ya
13:52volveremos cuando se haya sincronizado
13:57muy bien entonces en este momento como
14:00pueden ver tenemos ya sincronizado
14:02nuestro proyecto Ok y podemos empezar a
14:05trabajar sobre ello ahora si ustedes
14:08recuerdan Pues en el en el gráfico no en
14:11el diagrama que yo les presente Pues
14:13todo este proyecto todo esta
14:15implementación que nosotros vamos a
14:16realizar de Spring Security es para
14:19proteger este el acceso a este a esta a
14:24este backen no o en este caso a una Api
14:26redfoll que pues tiene recursos que
14:28pueden ser consumidos desde un cliente
14:30externo Ok entonces bueno Esto es algo
14:34que ya hemos hecho básicamente pero pues
14:37no no se pierde nada
14:39volviéndolo hacer vamos a crear una una
14:42un pequeño controlador Ok entonces vamos
14:45a crear nuestro paquete
14:47controller OK
14:49Vamos a crear una nueva clase que se
14:55llame saludo control
14:57[Música]
15:00perfecto vamos a indicarle Spring que es
15:03después un controlador Ok un controlador
15:06de tipo Rest
15:08un controlador de tipo Rest muy bien
15:11Vamos a colocar aquí la anotación Rest
15:14controller perfecto y vamos a crear un
15:18en Point no vamos a colocar Bueno vamos
15:20a colocarle Aquí también vamos a
15:22mantener un estándar no vamos a indicar
15:24que es mapping va a ser
15:27Slash Api Slash
15:31rating Ok y vamos a colocar aquí un en
15:35Point que sea get de tipo get y vamos a
15:39indicarle que este en Point va a ser 6
15:43Hello por ejemplo muy bien Vamos a crear
15:46un álbum que nos devuelva un String 6
15:49Hello perfecto
15:52nos va a retornar un String que diga
15:55Hello from Happy jacks por ejemplo muy
16:01bien entonces Bueno antes de continuar
16:04pues vamos a guardar obviamente vamos a
16:07intentar levantar este proyecto vamos a
16:09ver si es que nos arroja algún tipo de
16:11excepción no Ok entonces vamos a ver
16:16que nos indica habilitamos el
16:18procesamiento de anotaciones de longbook
16:19Ok Muy bien Y como pueden ver pues este
16:22nos arroja una primera excepción y es
16:24que si ustedes recuerdan yo añadí el
16:27driver de postres no O sea tiene que
16:30haber una conexión a una base de datos
16:32sql Y es lo que nos está indicando aquí
16:35prácticamente no nos dice que podemos
16:38poner una base de datos de embebida como
16:40h2 dhsql como la que trabajamos en la
16:43primera fase Y también puedes conectarlo
16:46a una base de datos como tal Ok entonces
16:48en este momento qué es lo que voy a
16:49hacer a continuación básicamente es
16:52copiar la configuración que ya hemos
16:55realizado Pues en vídeos anteriores a
16:59una base de datos ok
17:01muy bien entonces ya tenemos aquí ya la
17:04configuración en nuestro archivo
17:06application properties recuerden Pues
17:08que este archivo es bastante importante
17:09porque aquí se definen varias
17:11configuraciones no en este en esta fase
17:13del curso pues para ahorrarme tiempo no
17:14vamos a hacer nada de archivos punto gml
17:17Eso ya depende de la predilección y su
17:19preferencia si les gusta trabajar más
17:21con properties o con punto y ML Ok
17:23Perfecto entonces ya tenemos aquí la
17:26configuración para conectarnos a nuestra
17:28base de datos Recuerden que estamos
17:30trabajando con una base de datos postres
17:32entonces Bueno aquí está aquí tenemos
17:34creada dicha base de datos ya
17:37previamente Ok se llama Sprint Security
17:40datase Bueno es un nombre que le puse
17:42así para fines prácticos entonces aquí
17:45está la cadena de conexión y las
17:47credenciales de acceso y todo Entonces
17:48vamos a guardar cambios vamos Ahora sí a
17:52levantar nuestra aplicación y veamos si
17:55es que no ocurre ningún otro tipo de
17:56excepción
17:59Ok como pueden ver ya nuestra nuestra
18:02Api se ha levantado Ok perfecto vemos
18:06que la aplicación se ha inicializado y
18:09vamos a ver si en nuestro controlador
18:11está funcionando Perfecto entonces vamos
18:13a ir a nuestro navegador ok vamos a
18:15poner aquí local
18:18Host Ok puntos 80 85 es lash Api
18:24slashping Slash 6 Hello
18:28Ok y nos devuelve un Hello froms Ok
18:32entonces nuestra Api está levantada
18:34ahora para qué hice esto básicamente
18:35para ejemplificar que en este momento no
18:39hemos añadido ningún tipo de seguridad
18:41es a nuestro proyecto simplemente hemos
18:44creado un en Point al cual pues Nosotros
18:47le vamos a agregar seguridad es
18:49utilizando Spring Security y Jason web
18:52tokens Ok Perfecto entonces eso es lo
18:56que vamos a hacer a continuación
18:58implementar Springs
19:03muy bien entonces continuando con lo que
19:06venimos haciendo de la implementación
19:09aquí tenemos pues nuestro primer en
19:11Point que nosotros creamos y al que le
19:13queremos brindar seguridad Entonces
19:15ahora sí para empezar con la
19:17implementación vamos a ir a nuestro
19:18archivo de configuración pom y vamos a
19:21copiar la dependencia de Sprint starter
19:24Security Ok entonces para eso nosotros
19:26vamos a hacer un Maiden update OK Vamos
19:29a detener la aplicación un rato perfecto
19:31esperemos que se sincronice la
19:34dependencia de nuestro en nuestro
19:36proyecto muy bien ya sea sincronizado y
19:39ahora lo que vamos a hacer primero Bueno
19:41yo lo que primero quiero hacer es crear
19:44un nuevo paquete ok En este caso va a
19:46ser el de entity perfecto
19:50muy bien Ahora qué es lo que vamos a
19:52hacer vamos a crear nuestra entidad
19:54usuario OK Porque ahora queremos guardar
19:58en nuestra base de datos usuarios
19:59obviamente Entonces vamos a crear
20:01nuestra clase user Ok aquí tenemos
20:04nuestra clase user y bueno vamos a
20:06definir los atributos obviamente vamos a
20:09necesitar un ID también vamos a
20:12necesitar un
20:14bueno Considero que un primer nuestro
20:17nombre también vamos a tener nuestro
20:20apellido OK Vamos a manejar el email que
20:25va a funcionar como el usuario Ok va a
20:27ser String perfecto vamos a colocar la
20:31clave que sería String password muy bien
20:35estos son los atributos que a priori
20:37manejaría nuestra entidad Entonces vamos
20:39a anotarle como entity utilizando
20:42jacareta persistentes OK Vamos a
20:45definirlo como una entidad y como hemos
20:47venido haciendo Porque queremos evitar
20:49problemas de palabras reservadas de
20:52lenguaje en este caso nuestra base de
20:54datos de postres y user es una de las
20:55palabras reservadas entonces para
20:57evitarnos de ese problema Vamos a darle
20:59nuestro nombre a la tabla Y en este caso
21:02se mapearía como tbl y usa perfecto
21:06Vamos a darle vamos a colocarle longbook
21:10Ok Data para que resetters los
21:12constructores con el constructor de con
21:15todos los parámetros del constructor
21:17vacío y finalmente nuestro patrón
21:20builder muy bien perfecto
21:24ahora vamos a indicar cuál va a ser el
21:26ID
21:27muy bien y el General la forma en la
21:30degeneración de valores Entonces vamos a
21:32definir la estrategia como ya lo hicimos
21:34en la segunda fase de este curso vamos a
21:38colocar un generation type a identity en
21:41este caso para ahorrarnos más tiempo no
21:43quiero si pueden si no hay identidad
21:44perfecto nuestra entidad ahorita ya está
21:46configurada no es nada que no hayamos
21:48hecho ahora
21:50algo muy importante y aquí si ya viene
21:53un tema de Sprint Security vamos a
21:56utilizar e implementar esta entidad va a
21:59implementar una clase que se llama usert
22:02details Ok implements usert details como
22:06pueden ver es de ork Spring framework
22:09Security Core Ok entonces vamos a
22:11implementar esta clase como ven va a
22:13haber errores Entonces nos va a pedir
22:15que implementemos los métodos también
22:16podemos poner el cursor aquí arriba y
22:18aquí dice implementar métodos entonces
22:20son todos estos los métodos que nosotros
22:22necesitamos implementar
22:25perfecto Ok Recuerden que esta clase Ya
22:29pertenece a el corte de Spring Security
22:32Ok entonces veamos Cuáles son los
22:34métodos que se implementaron Pues en
22:37esta en nuestra entidad como pueden ver
22:39tenemos un método que se ya que nos da
22:45las autoritis no las autorities que no
22:48son más que
22:49[Música]
22:50la que los roles que tendría en este
22:52caso el usuario no Recuerden que pues
22:54hay sistemas en los que se manejan
22:55diferente tipo de permisos accesos como
22:58puede ser por ejemplo administrador un
23:00usuario simple super administrador
23:02etcétera Ok entonces este método nos
23:05ayuda a gestionar eso Entonces cuando
23:07nosotros estamos hablando de autoritis
23:09obviamente vamos a necesitar roles no
23:12cierto Entonces para eso nosotros lo que
23:15vamos a hacer a continuación es crear
23:17un enumerado Ok
23:20un enumerado que se llame
23:25Vamos a ponerle error Perfecto entonces
23:28este numerador rol va a tener dos roles
23:30Vamos a ponerle un usuario normal y va a
23:34tener un administrador nada más OK este
23:37va a ser estos van a ser los roles
23:39disponibles en nuestra aplicación
23:41entonces obviamente tenemos que nosotros
23:44pues este
23:46indicar que va a haber un atributo de
23:48tipo roles no en nuestra entidad y en
23:50este caso lo que vamos a colocar es un
23:53private
23:55[Música]
24:01perfecto pero tenemos que indicar que
24:04esto es un enumerado
24:08Okay perfección perfecto y vamos a
24:11indicarle que es un tipo de numerado
24:13ordinal muy
24:16bien entonces ya nosotros estamos
24:18indicando el rol entonces Dentro de este
24:20método lo que nosotros vamos a retornar
24:22es un una lista punto off una lista de
24:27elementos que va a ser un New simple
24:31durante
24:33autority Ok va a ser una New simple y
24:38vamos a
24:39retornar el nombre del rol que tiene
24:42este usuario perfecto ahora veamos Qué
24:45métodos más tienen dice que nos permite
24:49devolver el usuario Perfecto entonces
24:51vamos a retornar
24:53el nombre de usuario que en este caso
24:55sería nuestro email Recuerden que
24:57nosotros vamos a utilizar para este caso
24:58el email como el usuario en nuestra
25:01aplicación ya depende de ustedes ustedes
25:03pueden utilizar First o hacer que el
25:06usuario crea un nombre de usuario No ya
25:08son customizaciones que ustedes le Irán
25:11dando
25:13Próximamente Ok entonces tenemos más
25:16métodos por ejemplo encontramos un par
25:18de bolivianos aquí ya como por ejemplo
25:21es un boleano que nos indica que esta
25:23cuenta este usuario no ha expirado Ok
25:26entonces aquí nosotros vamos a retornar
25:29por defecto Trump ustedes también pueden
25:31este customizar estos métodos agregar
25:34métodos que les permitan pues validar si
25:36el usuario ya expirado tal vez esta
25:39cuenta ya caducado se puede hacer de
25:41todo con este tipo de con esta clase
25:44user details no También tenemos un
25:46método booleano que nos valida si es que
25:50la cuenta no ha sido bloqueada no como
25:52pueden ver hay varios sistemas por
25:54ejemplo no Facebook asumamos que en
25:56Facebook te has comportado mal y pues
25:58Facebook te bloqueó la cuenta para que
26:00ya no puedas acceder entonces este tipo
26:02de métodos nos ayudan a eso en este caso
26:04por defecto vamos a retornar true porque
26:06pues no queremos que ninguna cuenta esté
26:09bloqueada Ok aquí hay otro booleano que
26:12nos indica si credenciales no han
26:14expirado Ok entonces vamos a retornar un
26:18trío igual y si es que el usuario está
26:20habilitado no Recuerden que pueden haber
26:22lógicas de negocio detrás en donde
26:25cuando se crea un usuario ese usuario
26:27todavía está deshabilitado y se necesita
26:30pues posteriormente mediante un correo
26:33electrónico realizar una activación de
26:35ese usuario Ok Déjenme los Déjenme en
26:39los comentarios si es que les
26:40interesaría tal vez realizar una
26:41implementación similar los estaremos
26:43leyendo y estaremos considerando hacerlo
26:45entonces en este caso voy a poner por
26:47defecto true OK Para que este usuario o
26:51todos los usuarios que yo vaya creando
26:53pues estén habilitados no estén
26:55caducados no estén bloqueados perfecto
26:57sin embargo
26:59me falta un ghetter aquí Ok y es el del
27:04password no necesita también obtener el
27:06password entonces pues aquí Qué es lo
27:09que está pasando Pues por qué no me no
27:12nos no me sobres no me sobrecargue ese
27:13get es por mi anotación de Data Ok
27:16entonces Vamos a ponerle aquí
27:20Vamos a ponerle password 1 ok
27:25y vamos a hacer implementar ese método
27:27que me está faltando Ahí está get
27:29password Ok ahí tenemos get password y
27:32ya ponemos borrarle el uno que le
27:34colocamos aquí eso es un Life hacker que
27:37Les recomiendo y ahí sí vamos a retornar
27:39el password Perfecto entonces ya tenemos
27:42nuestra entidad configurada
27:52Perfecto entonces una vez que nosotros
27:54ya tenemos configurada nuestra entidad
27:56usuario no que es con la que vamos a
27:58gestionar los usuarios que van a tener
28:00acceso dentro de nuestra aplicación
28:02vamos a correr esta aplicación para que
28:05hyberney pues bueno mapee esta entidad
28:07Pues a la base de datos primero que nada
28:09entonces esperemos que se levante la
28:12aplicación okay entonces aquí está el
28:15ROM perfecto
28:19muy bien
28:20Ahí está hibernate ha hecho su trabajo
28:24como es debido Y si ustedes se fijan
28:27aquí Pues básicamente está utilizando
28:29algo que se llama using generated
28:31Security password que básicamente es la
28:34protección que por defecto viene cuando
28:37nosotros incluimos este tipo de
28:38librerías no a nuestra aplicación de
28:42Spring Boot entonces de cierta forma
28:44pues ya se protegen cualquier tipo de
28:47petición URL que nosotros creemos sin
28:49embargo nosotros vamos a customizar esa
28:53protección pero lo que podemos ya ver
28:55por el momento es que nosotros se
28:57refrescamos el esquema de base de datos
28:59que tenemos ya tenemos nuestra tabla
29:01user Y si yo hago un Select a esta tabla
29:04Okay
29:05Select from TV user
29:10Ahí está nuestra tabla con todos los
29:12campos que nosotros queremos manejar que
29:13es email First name Last name password y
29:16Rock Perfecto entonces cuál es el
29:18siguiente paso hacer a continuación Pues
29:21bueno vamos a crear un nuevo paquete
29:23Esto es algo que también ya hemos hecho
29:25en cursos anteriores Y vamos a crear un
29:27repositorio OK Para poder gestionar con
29:29jpa la entidad que nosotros creamos de
29:32user Entonces tenemos el repositorio
29:35perfecto creamos la nueva en este caso
29:38Recuerden que es una interfaz lo que
29:41nosotros vamos a manejar Aquí sí que
29:42vamos a colocar user repositor
29:45perfecto
29:47como es normal vamos a extender Ok de la
29:53interfaz de jpa repository OK Y ustedes
29:57recuerden Pues que aquí es maneja la
30:00clase con la que estamos nosotros
30:01trabajando Y también vamos a enviar el
30:04tipo de ID de esta entidad y vamos a
30:08anotarlo como un repositorio Perfecto
30:11entonces cuál es el método que nosotros
30:13vamos a configurar aquí que nosotros
30:15vamos a necesitar Pues básicamente
30:17un opcional
30:21Ok en opcional
30:26y vamos a traer este usuario
30:29por find user by email Recuerden que
30:34nosotros estamos utilizando
30:37el email como el usuario para poder
30:40nosotros loguearnos en la aplicación Ok
30:42Perfecto entonces ya hemos creado el
30:46repositorio
30:51muy bien una vez que nosotros hemos
30:53creado Pues el repositorio para poder
30:55gestionar nuestro usuario Ahora sí vamos
30:58a entrar en un poco de la implementación
31:00del esquema que yo les mostré pues al
31:03inicio no Ok entonces Bueno vamos a
31:06corregir esto de aquí sería user
31:09repository no repositoriotti
31:14[Música]
31:19perfecto
31:24ya perfecto
31:26Entonces ahora sí una vez que hemos
31:30corregido nosotros esto ya tenemos
31:31nuestro repositorio nuestra entidad y si
31:33nosotros vamos de nuevo Pues a nuestro
31:35diagrama ustedes van a ver bueno
31:38recordarán que yo les mencioné que
31:39siempre el filtro de autenticación es lo
31:42primero en lanzarse siempre en cada
31:44petición que se va a hacer hacia nuestro
31:46servidor no en este caso puede ser get
31:49post put o delete Ok entonces vamos a
31:52empezar con la implementación de esto y
31:55con la implementación de esto Y a medida
31:57que vayamos construyendo vamos a ver
31:59cómo nuestro proyecto va tomando forma
32:01en base a este esquema que se está
32:03presentando no Entonces para empezar con
32:06la implementación de esto nosotros vamos
32:07a regresar Pues a nuestro proyecto Ok y
32:12vamos a crear un nuevo
32:17y vamos a crear un nuevo paquete en este
32:19caso vamos a llamarle upsi un nuevo
32:23paquete en este caso que se va a llamar
32:25cómic OK Y en este paquete aquí nosotros
32:28vamos pues a crear todas las clases de
32:30configuración para poder establecer
32:31seguridad desde nuestra apio Ok entonces
32:34vamos a crear una nueva clase en este
32:36caso vamos a empezar con la construcción
32:38del filtro no Entonces vamos a ponerle
32:41jwbt filter de nombre Perfecto entonces
32:46esta clase lo que va a hacer va a ser
32:49extender métodos Pues de una interfaz
32:53que se llama One filter Recuerden que yo
32:55les mencioné que siempre este filtro es
32:59se va a ejecutar una vez en cada
33:01petición una vez en cada petición por
33:03eso se llama One request filter Ok si
33:06somos un poquito curiosos y vamos
33:07entrando a la clase a la interfase
33:09ustedes van a ver que está extiende de
33:11llenar el filter Bean y de la de la
33:14clase base Pues que
33:16que es filter no que funciona como un
33:19filtro y ya depende de ustedes si le
33:21meten un poquito más de investigación y
33:22van a ver que incluso hasta
33:23implementando filter como tal también se
33:26puede realizar el mismo proceso pero en
33:28este caso vamos a utilizar las
33:29herramientas que ya Spring Nos está
33:31dando Y en este caso vamos a utilizar
33:33One request filter Ok entonces
33:35importante vamos a anotar esta clase
33:38como componente para que sea
33:40identificada en el radar de Sprint del
33:42contenedor de Sprint para que actúe como
33:44un Bin también que tiene que ser
33:45ejecutado y vamos a colocarle que vamos
33:48a definir
33:50el constructor como requerido Ok
33:53entonces sería recuerded arts
33:55constructor Ok perfecto ahora como
33:58ustedes pueden ver me asomo un error y
34:00por qué porque tenemos que implementar
34:01los métodos el método más claro
34:04importante de esta clase que es del
34:06método filter interna perfecto
34:08implementamos el método vamos a ordenar
34:10un poquito este código aquí para que sea
34:12un poco más legible Ok importante que
34:15tenemos aquí dos filter internet recibe
34:18tres parámetros no en la ejecución de
34:21este método el primero es el request Qué
34:24es el request cabe recalcar que el
34:26request es lo que el cliente nos envía
34:29en la petición es decir lo que el
34:31cliente está mandando en su petición
34:33http Ok entonces este este ya van a ver
34:38tiene varios elementos internos que
34:41nosotros vamos a necesitar manipular
34:43para poder este llevar a cabo nuestro
34:45filtrado no que tenemos luego es el
34:49server response es lo que nosotros
34:51debemos de entregar al cliente una vez
34:53procesada su solicitud y filterchain
34:56Pues básicamente es un elemento que
34:58nosotros nos va a permitir a permitir
35:00pues este continuar con el proceso de la
35:03solicitud una vez que nosotros hayamos
35:04filtrado ok Ya lo vamos a ver cómo
35:06funciona
35:07entonces bueno en este caso para este
35:11para este caso en específico yo voy a
35:14pedir que por favor sean no nulos los
35:18valores que se envíen a este
35:21a este a este a este a este método Ok Ok
35:25Bueno Perfecto entonces qué es lo que
35:27vamos a necesitar a continuación bueno
35:28primero vamos a definir una variable va
35:32en el String en este caso se va a llamar
35:34Perdón out Head Ok y este out header es
35:39el header de autorización que nosotros
35:42vamos a necesitar y lo vamos a tomar del
35:44request OK Vamos a tomarle Get header
35:47out resecation que ustedes me dirán Alex
35:51Cómo sabes de dónde sale este este
35:54header de autorización si ustedes han
35:55sido un poco curiosos O tal vez alguna
35:57vez han visto aquí en postman o
35:59cualquier otra herramienta para testear
36:00apis ustedes van a fijarse que tenemos
36:03aquí un un encabezado de autorización
36:07que que se envía en cada petición no por
36:10ejemplo en este caso pues no no nos está
36:12enviando nada pero ustedes van a ver
36:14aquí que tenemos diferentes formas de de
36:17autenticación como a piquín
36:19y JW TV o el protocolo auto Dos punto
36:24cero o uno punto cero etcétera Ok
36:27entonces qué es lo que estoy indicando
36:28aquí sabes que voy a obtener el header
36:31de autorización Ok entonces voy a ver
36:36primero Aquí estoy validando si me están
36:37mandando algo en este header
36:40muy bien ya les voy a ir explicando un
36:42poquito más a fondo Vamos a continuar
36:44vamos a definir un String que va a ser
36:47nuestro Jason web token Y también vamos
36:49a necesitar un String que sea el email
36:52del usuario Recuerden que nosotros el
36:54email lo estamos utilizando como el
36:57usuario para poder autenticarse dentro
36:58de nuestro sistema perfecto ahora qué es
37:01lo que vamos a hacer a continuación
37:02Vamos a entrar en la primera validación
37:05ya de nuestro filtro y es que vamos a
37:08indicar lo siguiente primero
37:12si nuestro
37:15si nuestro out header Es nulo OK o
37:22si nuestro
37:25si nuestros y nuestros y nuestro out
37:28header
37:29no empieza con
37:33Beer Ok si uno empieza con beatter
37:36Entonces vamos a utilizar Chain
37:39Recuerden que este filter chine es el
37:40que tengo como parámetro aquí que se
37:42está inyectando y que me va a permitir a
37:44mí continuar con el proceso no Entonces
37:46vamos a
37:49continuar con nuestro proceso le
37:50enviamos request response y simplemente
37:52vamos a retornar la petición OK ahora
37:56qué estoy haciendo en este filtro
37:57ustedes recordarán que yo mencioné que
38:01aquí justo aquí en nuestro filtro de
38:04autenticación se valida si el usuario en
38:07su petición me está enviando primero que
38:10nada un Jason web Ok entonces qué es lo
38:14que estoy haciendo aquí primero
38:15verificar que me esté mandando un header
38:18de autorización es decir un Jason
38:20webdock si es que es igual a nulo si es
38:23que es igual a nulo retorna y te voy a
38:25devolver un estatus 403 porque no me
38:28estás enviando tus credenciales de
38:29acceso al sistema Ahora si me envías
38:31unas credenciales Pero estas
38:33credenciales no empiezan con bitter
38:35porque el tipo de autenticación que
38:37estoy utilizando en el token es Beer
38:39sino Si no si no empieza con esto De
38:43igual forma yo te voy a devolver un 403
38:45y no te voy a permitir autenticarte Ok
38:48eso es lo en la primera validación que
38:50nosotros vamos a realizar en este método
38:52de filter interna Ya suponiendo que en
38:56este caso bueno se pasa esta validación
38:59sabes qué me estás enviando un Jason web
39:01token empieza con beatter perfecto
39:04continuamos con el filtrado ahora vamos
39:07a Ahora sí a decir sabes qué tu Jason
39:10web token parece válido Así que voy a
39:13tomar de lado header y voy a tomar del
39:16Super String 7 Porque 7 Porque
39:19Generalmente cuando se envía un beatter
39:21token vamos a ponerles un ejemplo aquí
39:25aquí mismo digamos que cuando se envía
39:28la petición siempre empieza con bitter
39:31un espacio y aquí viene el token no este
39:35en este caso sería el token entonces
39:36obviamente yo voy a tomar este valor de
39:39aquí es por eso que el out header le
39:41mando con un sub String de 7 para que
39:43desde El séptimo carácter es decir 1 2 3
39:464 5 6 7 desde aquí se tome el token y
39:50esta parte de aquí ya entraría en este
39:52String que yo declaré en un inicio OK
39:54Para que se entienda vamos a borrarlo
39:57perfecto una vez que nosotros definimos
40:00el Jason web token vamos a este
40:03web token y vamos a definir el email
40:06para esto vamos a necesitar un servicio
40:08Ok que
40:11vamos a necesitar un servicio con un
40:14método que sea get user Ok este servicio
40:18todavía no lo creo ya lo vamos a crear y
40:21vamos a enviarle aquí nuestro Jason web
40:23Talk perfecto
40:25continuemos ya te definí el Jason web
40:28token que me estás enviando y quiero
40:29extraer el email de este Jason web token
40:33que tú me estás enviando perfecto ahora
40:35vamos a entrar en la siguiente
40:37validación y vamos a indicar Sabes qué
40:39Si es que el usuario en este caso pues
40:42es nulo Ok si es que el usuario es nulo
40:45y también quiero verificar si es que el
40:48contexto de
40:50el contexto de seguridad punto get
40:53context
40:55authentication es nula
40:59vas a proseguir con tu proceso de
41:01autenticación que estoy validando aquí
41:03para recapitular Primero quiero ver que
41:06el usuario pues no se anula no y segundo
41:10Quiero ver que no exista una y que en
41:13esta petición ya no estés autenticado
41:14porque sería pues este un poco una
41:18pérdida de tiempo que por ejemplo en
41:19este caso si tú estás autenticado
41:21continuar con el proceso de
41:22autenticación si todavía no lo estás no
41:25entonces Bueno aquí estoy simplemente
41:28validando que
41:30que este que este usuario pues no esté
41:33autenticado Ok entonces perfecto
41:36[Música]
41:39Ah perdón No es que sea igual a nulo
41:41sino que sea diferente de uno es decir
41:43si es que el usuario es diferente de
41:44nulo y no estás autenticado Vamos a
41:47continuar con el proceso de
41:48autenticación OK ahora vamos a utilizar
41:51vamos a crear un objeto user details va
41:55a ser igual y muy importante vamos a
41:58necesitar una interfase que pertenece al
42:02Core de Spring Security que es Gears
42:04user
42:06user details service Ok entonces vamos a
42:10inyectar ese
42:11[Música]
42:12vamos a inyectar ese ese objeto Aquí
42:14vamos a colocarle aquí Perfecto es un
42:17private es un final es user details
42:21service userve Beta service OK ahora si
42:25nosotros entramos a esta interfase
42:27ustedes van a ver que nosotros tenemos
42:28un método que se llama load by user user
42:32by user name cargar el usuario por su
42:35usuario muy interesante esta interfase
42:37Ok y ahora vamos a ver por qué vamos a
42:40colocar 10 puntos
42:44y le vamos a mandar el user email
42:48perfecto
42:50OK ahora qué es lo que estoy haciendo
42:52aquí si nosotros regresamos a nuestro
42:56a nuestro gráfico ustedes van a ver aquí
42:58que tengo el user detail service Ok y
43:02este user del service lo que hace es
43:04básicamente ir directo a mi base de
43:07datos y verificar que mediante el email
43:10este usuario realmente exista dentro de
43:13mi sistema Ok entonces como ustedes
43:16pueden ver ya va tomando un poco de
43:17forma la implementación de este esquema
43:20no de seguridad dentro de nuestra
43:22aplicación entonces muy importante Ya
43:25estamos entrando aquí en usert de Tales
43:27sir Ok entonces bueno
43:29tomate service y lo que voy a hacer es
43:32este validar validar realizar la
43:37siguiente validación Ok este servicio
43:39que aún no lo creamos Ok va a tener un
43:42método que se llame
43:49validate talking OK Vamos a llamarlo así
43:53Ok entonces aquí qué es lo que estamos
43:55validando
43:58si el token es válido en este caso ya
44:01estaríamos entrando en la parte de aquí
44:02Ok validar si es que el token es válido
44:04Ok
44:06si no pues si es válido Vamos a
44:09continuar con el proceso sino vamos a
44:11retornar de un 403 Ok validar si es que
44:14este token es auténtico más que nada
44:15entonces así lo que vamos a hacer es
44:17enviar un Jason web token Ok y aparte de
44:20nuestro Jason web token lo que vamos
44:21también a enviar Es los detalles del
44:24usuario perfecto
44:27entonces obviamente este método lo que
44:29nos va a retornar es un booleano
44:32continuamos con el proceso
44:36Ok entonces si el token es válido lo que
44:41vamos a hacer ahora sí es crear un
44:43objeto que es user name password
44:45authentication token ok
44:49vamos a colocarle igual Bueno muy muy
44:52largo ese nombre vamos a poner
44:53autentication token estamos construyendo
44:55el token y vamos a crear el objeto y en
44:59su constructor lo que vamos a hacer es
45:01enviar los user details vamos a enviar
45:03ahorita vamos a enviar las credenciales
45:05como nulos Y también vamos a enviar los
45:09autoritarios no los permisos que en este
45:11caso el usuario tiene y una vez que
45:13nosotros enviamos de los permisos vamos
45:15a crear los detalles de nuestra petición
45:17no Entonces vamos a utilizar
45:19autentication token y vamos a ponerle
45:21los detalles que entra dentro de los
45:23detalles bueno utilizamos el objeto web
45:25autentication de detail source para
45:28especificar que este que los detalles
45:31vienen Pues dentro de la dentro del
45:34Records no dentro de la petición y
45:36aparte de esto también lo que vamos a
45:38hacer es actualizar el Security context
45:40vamos a obtener el contexto y le vamos a
45:43colocar la autenticación que en este
45:45caso es del Jason webtop perdón es del
45:49objeto autentication token que ya este
45:51objeto Pues básicamente
45:53va cargado con el con el token y con las
45:58con los detalles del usuario y también
45:59con los permisos que el usuario ya tiene
46:01no Una vez que se ha hecho esto Pues
46:03básicamente ya lo único que resta por
46:06hacer es colocar el método filter
46:08change.tu filter request response
46:14perfecto ahora ahora como ustedes pueden
46:18ver pues hemos creado nosotros nuestro
46:20filtro de autenticación si vamos aquí
46:22Bueno la lógica Todavía falta
46:24implementar el Jason el jwt service pero
46:28hasta este punto nosotros ya hemos
46:30creado la lógica de lo que viene siendo
46:32como trabajaría nuestro filtro de
46:34autenticación One Spring
46:36ok
46:38perfecto
46:46Ok Muy bien Entonces una vez que
46:48nosotros Pues básicamente hemos creado
46:50nuestra lógica de nuestro filtro como
46:53tal Qué es lo que resta por hacer
46:55regresamos un momento a nuestro diagrama
46:58y como ustedes verán Pues básicamente ya
47:00tenemos la parte del filtro el user de
47:03tel service que nos va a traer
47:04directamente el usuario para verificar
47:06si existe o no existe Y qué es lo que
47:09resta por hacer es el proceso de
47:10validación de nuestro Jason web token
47:13como tal Ok entonces si nosotros vamos a
47:16nuestra clase del filtro ustedes verán
47:18que aquí tengo Pues un servicio que yo
47:20aún no he implementado en donde tenemos
47:23un método que username y otro de validar
47:26el token Ok entonces Pues básicamente
47:28eso es lo que nosotros vamos a
47:30implementar en este momento junto con
47:33otros métodos dentro de esa clase que
47:35servirán en el procesamiento de la
47:37validación de nuestro Jason web
47:40para ello Nos dirigimos a nuestra a
47:42nuestro paquete de configuración y lo
47:44que vamos a hacer es crear una clase que
47:46se llame jbl Service
47:49Ok y como su nombre mismo lo indica
47:52vamos a colocar aquí la anotación
47:54service para que el contenedor de Sprint
47:57lo identifique como tal Ok entonces qué
48:00es lo primero que nosotros vamos a
48:02necesitar Aquí vamos a necesitar
48:05un atributo estático y que sea privado y
48:09final que se va a llamar
48:12Secret key Ok Qué es la Secret key Bueno
48:16es muy posible que ustedes hayan
48:18escuchado Este término de Secret King
48:20básicamente es una clave secreta en
48:24español que sirve para firmar y
48:26verificar que los tokens que nosotros
48:28estamos generando no el que el jwt sea
48:31auténtico ahora algo muy importante esta
48:34cadena que yo estoy a punto de colocar
48:36Aquí la estoy colocando en código con
48:40fines prácticos Generalmente en un
48:42entorno de producción dependiendo del
48:45lugar en donde ustedes estén trabajando
48:46pues no es recomendable colocar aquí en
48:50código como tal yo simplemente lo estoy
48:51poniendo en una forma de ejemplo
48:54Entonces en ese caso pues dependiendo de
48:57en donde ustedes estén trabajando va a
48:58haber herramientas en donde se gestionen
49:00este tipo de secrets Para mayor
49:02protección de los datos y seguridad de
49:04nuestra Api restword OK Pero yo por el
49:08momento voy a colocarlo aquí ahora de
49:10dónde voy a obtener esta Secret key
49:12básicamente Pues hay varias herramientas
49:14que nos permiten a nosotros pues
49:16trabajar con con generadores no yo voy a
49:20utilizar esta de aquí Ok esta me va a
49:23generar una cadena de caracteres de 256
49:26bytes bueno bits perdón y esta cadena de
49:30caracteres Bueno yo la utilizo con 256
49:33bits porque porque básicamente vamos a
49:36trabajar con el algoritmo hs 256 si
49:39nosotros este pues vamos a nuestra
49:42página jwt punto io ustedes recordarán
49:46que pues del Jason de ejemplo pues aquí
49:48tiene una del tipo de algoritmo con el
49:51que se está este generando este Jason
49:54web token y como vamos a utilizar este
49:56de aquí es recomendable utilizar una
49:59cadena de caracteres de 256 bits Por
50:01ende voy a utilizar esto Ok como pueden
50:04ver pues aquí yo puedo ir regenerando
50:05regenerando para tomar la que me parezca
50:08conveniente Ok si ustedes desean Pues
50:11voy a dejarles el link de esta
50:13herramienta en la descripción y si no
50:15pues pueden simplemente Buscar en Google
50:17colocar Secret y generator y ahí pueden
50:21encontrar un sinfín de herramientas que
50:23pues les permitirá hacer esto Ok
50:24entonces yo voy a copiar esta de aquí
50:27específicamente muy bien regresamos a
50:31nuestra a nuestro código y lo vamos a
50:33colocar aquí perfecto ahora
50:37Qué es lo primero que nosotros vamos a
50:39realizar básicamente es bueno vamos a
50:42nuestra a nuestro filtro y el primer
50:44método que nosotros nos encontramos es
50:46para eso como yo ya creé la clase vamos
50:49a inyectarla en nuestro filtro Ok
50:53seríate final
50:54JW TT service
50:58perfecto y vamos a crear el método
51:01Entonces el primer método con el que nos
51:04topamos es get user name y le vamos a
51:06enviar el token como tal Así que vamos a
51:08cambiarle el nombre de esto es un token
51:10este método nos devuelve
51:12[Música]
51:14un String no Entonces qué es lo que
51:16vamos a hacer a continuación vamos a
51:18este crear un método genérico no Ok este
51:24método lo voy a llamar
51:28getclain vamos a llamarlo así get Klein
51:32y le vamos a enviar el token Y también
51:35vamos a utilizar
51:37la clase cleans Ok y vamos a utilizar
51:42el método Bueno no es una clase esto Más
51:45bien es una interfase no que se va a
51:47llamar get Ok general este método por en
51:51general pues me sirve para obtener el
51:53nombre del usuario del token que se está
51:55enviando OK ahora esta clase como
51:59ustedes pueden ver no existe como tal
52:01porque porque me falta agregar ciertas
52:03dependencias a la configuración de mi
52:06aplicación Ok entonces vamos a
52:09dirigirnos a nuestro archivo pom como
52:11tal y vamos a bajar OK Vamos a colocarla
52:14después de aquí de la dependencia del
52:16longbook entonces la primera dependencia
52:18que nosotros vamos a utilizar es la
52:21dependencia De
52:23jjwt Api ok
52:26la siguiente que vamos a utilizar es
52:29jjwt implementation o imprl y la última
52:34que vamos a utilizar en este caso va a
52:37ser
52:37jjwt Jackson OK ahora ustedes se
52:41preguntarán Para qué me sirve cada una
52:43de estas dependencias básicamente la
52:46primera
52:47jjwtapi es una dependencia que contiene
52:49interfaces para trabajar con Jason web
52:51tokens como tal es decir nos proporciona
52:53abstracciones no interfaces como tal la
52:56jjwt implementation tiene las
52:59implementaciones de las interfaces que
53:02tiene
53:03jjwtop es decir aquí ya está pues la
53:05lógica detrás de estas interfaces y
53:08finalmente tenemos una dependencia que
53:10es JJ Jackson que básicamente es una
53:14dependencia que se agrega para la
53:16serialización y de esencialización de
53:18Jason web tokens a Jason utilizando pues
53:21la ya la famosa librería que gestiona
53:24Jason de Spring ok Perfecto entonces una
53:27vez que nosotros hemos agregado estas
53:29dependencias vamos a hacer un Maiden
53:31update Ok si ustedes recuerdan pues este
53:34Cómo puedo obtener estas dependencias
53:36podemos ir también al buscador
53:39colocar por ejemplo jjlvente guión
53:44repository y pues aquí ustedes van a
53:46poder encontrar
53:47la última versión de esa dependencia no
53:50y así con todas las demás Entonces por
53:52ese lado ningún problema ok Ya vamos a
53:55de nuevo a nuestro proyecto ok Ya se han
53:58sincronizado nuestras dependencias y
54:00vamos de nuevo nuestro servicio entonces
54:02en este caso van Bueno vamos a guardar
54:04de nuevo vamos a colocar kleins como
54:06pueden ver esta interfase ya está de io
54:09punto Jason web token Ok y vamos a
54:12utilizar
54:13su método get socket como tal Ok que me
54:16va a permitir Pues básicamente a mí en
54:19esta interfase obtener pues
54:22el subject no el en este caso el nombre
54:25de usuario del jwbt que estamos enviando
54:28Ok perfecto si ustedes son curiosos pues
54:31ustedes ya Irán viendo qué más
54:32características tiene esta clase Ok
54:35entonces Bueno ahora vamos a crear este
54:37método genérico Ok qué es lo que tenemos
54:41Dentro de este método genérico Bueno
54:43vamos a implementar lo siguiente OK
54:46Vamos a crear aquí mismo vamos a poner
54:48public que como es un método genérico
54:50vamos a colocar el objeto t Ok y le
54:54vamos a poner get Clean como tal para
54:56que ahí esté la implementación Y vamos a
54:59recibir pues como tal un String que es
55:01el token Y también vamos a inyectar pues
55:04una función ok En este caso va a ser una
55:08función OK Vamos a colocar una función y
55:11vamos a colocar aquí la interfaz clames
55:15y vamos a colocar el objeto t Ok y vamos
55:18a llamarle clanes
55:20[Música]
55:22entonces colocamos esto Aquí vamos a
55:25importar la función Ok la interfaz de
55:28función de los ítems de Java perfecto y
55:32lo que vamos a hacer a continuación
55:33Dentro de este método Ok va a ser
55:36primero definir una variable final de
55:39tipo cleans cleans y vamos a necesitar
55:43aquí crear un método que se llame get
55:46all planes Ok perfecto y este método va
55:51a vamos a enviarle un toque Ok porque
55:53vamos a tener que obtener todas las
55:55reclamaciones del del token que nosotros
55:58estamos enviando Entonces vamos a
56:00retornar
56:02clanes resourver punto Apple Ok
56:05Recuerden que está esta clase yo lo
56:07estoy pues bueno este método yo lo estoy
56:09inyectando dentro de la función Ok y le
56:12vamos a enviar los links que se
56:13devolvieron de este método que quedó Ok
56:17entonces vamos a crear este método de
56:20Doll klains
56:21perfecto que nos va a deformar devolver
56:24Pues los clips como tal y vamos a
56:27utilizar para esto OK Vamos a utilizar
56:30este también una clase de io punto Jason
56:33web token que se llama
56:35jw.s Ok y esta básicamente Bueno vamos a
56:40utilizar el método punto
56:46y vamos a setear la clave de la firma Ok
56:51entonces
56:52qué es lo que vamos a hacer aquí adentro
56:54Bueno vamos a obtener vamos a tener que
56:57crear otro método que se llame obtener
56:59la clave de la firma Ok getsing
57:03que ya vamos a crear este Método en un
57:06momento vamos a utilizar el
57:09builds aclames Jason JW s Ok y vamos a
57:15enviarle perfecto vamos a obtener el
57:18body de esto Muy bien Entonces qué es lo
57:20que tenemos que hacer nosotros aquí es
57:22crear el método
57:24muy bien
57:26este Método en realidad no nos va a
57:29devolver un by that right sino más bien
57:30nos va a devolver un key Ok entonces
57:33para ello qué es lo que vamos a hacer
57:36vamos a este básicamente con este método
57:40nosotros lo que vamos a hacer es
57:43cómo cómo podríamos decirlo
57:47vamos a tomar la clave secreta no o sea
57:50es decir vamos a tomar esta clave aquí
57:53que nosotros estamos utilizando Aquí
57:54vamos a tomar esta clave secreta y vamos
57:57este a convertirla en base 64 como tal
58:01entonces para eso qué es lo que vamos a
58:03hacer vamos a utilizar nosotros bueno
58:06primero lo que vamos a hacer es crear un
58:08objeto de tipo by the right okay
58:10Bye
58:12y vamos a ponerle cake de nombre y vamos
58:16a utilizar la clase de colders Ok de
58:20coders y vamos a tomar el secreto en
58:23base
58:2464.code y le vamos a colocar aquí la
58:27Secret perfecto y lo que vamos a
58:30retornar nosotros básicamente es
58:35crean o sea vamos a crear y vamos a
58:38retornar una firma H Mac utilizando una
58:42clase de Java que se llama Case Ok esta
58:46clase que me va a permitir a mí
58:48básicamente hacer esta clase como digo
58:51me va a permitir es crear una nueva
58:53firma Perdón
58:55hmac checky Ford Okay y Aquí vamos
58:58nosotros a enviar los keytes que
59:01Nosotros acabamos de crear
59:02Perfecto entonces para recapitular qué
59:06es lo que hice el método obtener usuario
59:09Ok el método obtener nombre de usuario
59:12utiliza el método obtener reclamación Ok
59:15y le enviamos el token que nos están
59:19enviando en el request Ok entonces
59:21Nosotros le enviamos el token que le
59:23enviamos en el recuento y estamos Este
59:25inyectando el método get soject de la
59:27interfase cleans para poder obtener el
59:30subjet bueno en este caso el usuario del
59:33token que nosotros estamos
59:36mandando este método get Klein este toma
59:40bueno crea un objeto de tipo cleans y
59:43utiliza el método get klames enviándole
59:46el token Ok este método quedó cleans
59:48utiliza la clase Jason web token bueno
59:52jw.ts y lo que hace básicamente este
59:56este método es utilizar Pues de la la
1:00:00firma no es decir Tomar la Secret key
1:00:02decodificar en base 64 y crear una nueva
1:00:06firma
1:00:06hechiford Ok entonces una vez que
1:00:09nosotros devolvemos la firma obtenemos
1:00:13todos los clames Ok los clips del token
1:00:15que nosotros estamos enviando retornamos
1:00:18del claim Resort punto a Play Clean
1:00:21cleans Ok y básicamente ya obtenemos el
1:00:25nombre del usuario del token que
1:00:27nosotros estamos enviando ok
1:00:30perfecto Espero que se haya comprendido
1:00:32un poco mejor esto ahora
1:00:35que nos resta a nosotros por hacer
1:00:38básicamente nosotros qué es lo que
1:00:41nosotros
1:00:43básicamente hacemos Bueno vamos a
1:00:46retornar a nuestro filtro y ya
1:00:49implementamos el proceso de obtener el
1:00:50usuario Ok del Jason web token que nos
1:00:52están enviando ahora lo que nosotros
1:00:54tenemos que hacer es validar que
1:00:57efectivamente ese token este sea
1:01:00auténtico no Entonces vamos a crear ese
1:01:03método que se llame validate top Ok
1:01:07entonces para eso
1:01:09creamos este validay token que es un
1:01:12método de tipo booleano Ok aquí le vamos
1:01:14a enviar el el Jason bueno en este caso
1:01:17sería el token no el token que nos están
1:01:19enviando en la petición y los user
1:01:21details los detalles del usuario ok
1:01:25Entonces qué es lo que vamos a hacer
1:01:26aquí primero vamos a crear una un String
1:01:30de tipo final Ok que se va a llamar
1:01:32nombre de usuario Ok y vamos a Bueno
1:01:36vamos a necesitar un método que se llame
1:01:37get
1:01:39el Ok Recuerden que ya ya creamos de ese
1:01:43método Ok entonces enviamos el el que
1:01:47recuerden es de este mismo de aquí
1:01:48entonces necesito tomar el nombre de
1:01:50usuario y lo que vamos a hacer a
1:01:52continuación es retornar
1:01:55Ok sería como y vamos a comparar esto y
1:02:00cuál es con los user details que estamos
1:02:04mandando en el proyecto Entonces vamos a
1:02:07obtener el username del user details Ok
1:02:10y tiene que ser igual al usuario que yo
1:02:14estoy extrayendo del token Ok
1:02:18perfecto y además aparte de eso
1:02:22tenemos que
1:02:25decirle a esto que si es el token no ha
1:02:29expirado no O sea y toquen xpire
1:02:33entonces para eso vamos a crear un
1:02:34método que verifique que efectivamente
1:02:36el token no no no no no ha expirado no O
1:02:40sea que no ha pasado su periodo de
1:02:43expiración y para eso lo que vamos a
1:02:45hacer es crear este método de aquí que
1:02:48se llame is token Entonces vamos a crear
1:02:52este método que igual nos va a devolver
1:02:54un booleano y básicamente este método
1:02:56nos va a retornar
1:02:58vamos a dejarlo así para mantener el
1:03:01código más simple nos va a retornar el
1:03:04resultado de otro método que se va a
1:03:06llamar
1:03:11OK enviamos el toque
1:03:14punto pifore Ok y le vamos a enviar
1:03:19New date OK Vamos a enviarle inyectarle
1:03:23la la clase de tipo fecha de Java Ok
1:03:27entonces vamos a crear este método que
1:03:29despiration
1:03:31Ok perfecto
1:03:36Y qué es lo que va a retornar este
1:03:38método que da expiration básicamente
1:03:40vamos a utilizar la interfase cleans de
1:03:43io punto Jason web token vamos a
1:03:45retornar Ok xtrack Plane
1:03:52no perdón no se llama strange se llama
1:03:54get Clean Ok y le vamos a enviar el
1:03:57token y le vamos a inyectar la interfase
1:04:00get en este caso como pueden ver tenemos
1:04:03get expiration justo aquí
1:04:07Ok
1:04:08perfecto punto y coma aquí y ya tenemos
1:04:11acá también tenemos que agregar un punto
1:04:13y coma Ok entonces como pueden ver esta
1:04:16interfase Clean que yo pues estoy
1:04:17utilizando es muy útil para obtener pues
1:04:19varias varias este varias diferentes
1:04:23tipo de información del token que me
1:04:26están enviando como pueden ver por
1:04:28ejemplo puedo obtener el nombre ok y el
1:04:31usuario puede obtener la información
1:04:33como la la expiration Ok puedo obtener
1:04:37el ID Ok entonces son es varios tipos de
1:04:41reclamaciones que yo puedo hacer
1:04:42mediante esta interfase que me permite a
1:04:45mí pues obtener cierto tipo de
1:04:46información de Jason web token que se ha
1:04:50generado para este efectivamente saber
1:04:53si es que este Jason web token es válido
1:04:56no Ok entonces bastante interesante esta
1:04:59clase de tipo clems junto con su
1:05:01implementación
1:05:03Entonces como pueden ver efectivamente
1:05:05pues ya hemos hecho la la implementación
1:05:10de obtener el usuario y la validación de
1:05:14el Jason webtock
1:05:22Muy bien Entonces hasta este punto ya
1:05:25hemos nosotros pues
1:05:27configurado no que cuando se envía una
1:05:30petición Pues básicamente
1:05:33se Lance el one Quest filter que es
1:05:36nuestro filtro de Jason web token y
1:05:39también hemos de hecho el proceso de
1:05:42validación de nuestro Jason web token no
1:05:45Ok como podemos ver aquí hemos este
1:05:48implementado el proceso de validación
1:05:50por ejemplo también el de obtener el
1:05:53usuario que pues como mencioné en un
1:05:55inicio va a ser el email no el email va
1:05:58a ser el que funcione como el usuario
1:06:00para poderse autenticar a nuestra
1:06:03aplicación ahora
1:06:05algo muy importante no ya hemos hecho
1:06:09pues del proceso de validar el token no
1:06:12el token que nos esté enviando cualquier
1:06:14cliente mediante una petición
1:06:17pero también pues nuestra Api tiene que
1:06:20generar esos tokens por sí misma OK Para
1:06:23poder validar que sea Auténticos es
1:06:25decir yo debo en mi Api implementar el
1:06:30proceso de que pues entregarle un clic a
1:06:33un cliente un token auténtico para que
1:06:36éste pueda acceder a los recursos de
1:06:39nuestra aplicación Entonces eso es lo
1:06:42que vamos a implementar ahora en nuestro
1:06:45servicio Ok entonces para eso lo que
1:06:48vamos a hacer es generar ese toque Muy
1:06:52bien Entonces vamos a crear un nuevo
1:06:53método que lo vamos a llamar public
1:06:56va a retornar un String que en este caso
1:06:59va a ser el token Ok y le vamos a
1:07:02colocar generate toque Ok perfecto
1:07:08muy bien
1:07:09Entonces qué es lo que vamos nosotros a
1:07:12enviar este vamos a enviar un
1:07:15map no un objeto map OK Por si este
1:07:19tengo este
1:07:22klains o reclamaciones extra No desde el
1:07:25token Ok Ok en este caso vamos a
1:07:28importar
1:07:29la interfase de map de Los Beatles de
1:07:32Java y vamos a ponerle aquí
1:07:35clanes OK Por si tengo extra o pongamos
1:07:39aquí clims Ok y vamos a enviarle los
1:07:44detalles del usuario de Us okay
1:07:48Perfecto entonces qué es lo que nosotros
1:07:51vamos a hacer aquí Bueno vamos a
1:07:53utilizar la misma clase que nosotros
1:07:55utilizamos acá OK Para para para poder
1:07:59obtener todas las reclamaciones del
1:08:01Jason web token que nos están enviando
1:08:03Pero esta vez para generar ese toque
1:08:05Entonces vamos a hacer un bretón
1:08:08jwts Ok punto y en este caso vamos a
1:08:12utilizar builder OK el builder Recuerden
1:08:16que esta clase pertenece Pues
1:08:17básicamente alcor de de io punto Jason
1:08:21web token Ok entonces vamos a utilizar
1:08:23el builder Y en este caso vamos a setear
1:08:27los clanes y vamos a
1:08:31enviar los dextragames que pues se nos
1:08:35están otorgando aquí no OK ahora vamos a
1:08:39colocar el set sadget Y en este caso
1:08:41pues vamos a mandarle el email no O sea
1:08:44el email que nosotros estamos obteniendo
1:08:46deltails Ok entonces vamos a poner que
1:08:49en este caso get username OK Vamos a
1:08:53colocarle el la fecha en la que se que
1:08:58se genera el token no Entonces vamos a
1:08:59poner el set at OK Vamos a colocar el
1:09:03nuevo objeto de tipo date y vamos a
1:09:06utilizar pues la
1:09:10la hora y bueno la fecha básicamente de
1:09:14en el instante en el que se genere el
1:09:16token no Y también vamos a colocarle la
1:09:19fecha de expiración de ese token
1:09:21entonces vamos a también enviarle un
1:09:24objeto de tipo date vamos a colocar
1:09:27desde el momento en el que se genera Ok
1:09:30y como estamos hablando de Pues de de
1:09:34milisegundos tenemos que sumarle los
1:09:371000 de esos milisegundos multiplicar
1:09:39por 60 Ok y por 24 así que de esta forma
1:09:44Estamos dándole un tiempo de expiración
1:09:46a nuestro token Pues de 24 horas es
1:09:49decir en 24 horas de este token ya
1:09:51dejará de ser pálido y pues en caso de
1:09:54que nos envíen el mismo token después de
1:09:56esas 24 horas vamos a retornar un 403 Ok
1:10:00perfecto y vamos a colocar
1:10:04la firma no el algoritmo de firma que ya
1:10:07he mencionado antes Ok entonces para eso
1:10:11vamos a utilizar el método que creamos
1:10:13get OK Para obtener decodificado Ok el
1:10:18la Secret que nosotros enviamos
1:10:20recuerden es de este método de aquí Ok y
1:10:24aparte de eso vamos a mandarle el
1:10:26algoritmo de la firma en este caso vamos
1:10:29a utilizar como ya mencioné el hs 206
1:10:34perfecto muy bien colocamos compact OK
1:10:39Para que se haga todo esto un String Y
1:10:42tenemos el método de generar toque Ahora
1:10:45yo por el momento pues no no no no no no
1:10:48quiero utilizar los extraclames Ok
1:10:51simplemente quiero generar este token a
1:10:54partir Pues de los user details Cómo se
1:10:57hace esto Pues bueno lo que vamos a
1:10:58hacer es crear una sobrecarga de este
1:11:01método no vamos a ponerle publiques
1:11:03[Música]
1:11:05Ok y simplemente user le vamos a enviar
1:11:11los
1:11:14y vamos a invocar al método general
1:11:18vamos a poner aquí return y vamos a
1:11:20llamar al generate token que acabamos de
1:11:22crear le vamos a enviar un nuevo
1:11:26vacío okay sin clames y le vamos a
1:11:29enviarlos yo soy
1:11:32Perfecto entonces con esta
1:11:35implementación ya podemos este empezar a
1:11:38realizar lo que es pues del servicio de
1:11:41autenticación Ok entonces
1:11:44ya vamos a ver cómo se hace
1:11:48perfecto Ok entonces nosotros podemos
1:11:51generar Pues los métodos de valga la
1:11:54redundancia generar el token no
1:11:57entregarle un toque en el cliente Para
1:11:58poder pues este permitirle que
1:12:02acceda los recursos de nuestra
1:12:04aplicación Ok entonces me gustaría mover
1:12:07un momento al filtro OK Y si nos
1:12:10dirigimos a esta parte de aquí cuando
1:12:12nosotros pues bueno obtenemos el usuario
1:12:14del Jason web token que en este caso se
1:12:17envía en el request Ok entramos en la
1:12:20validación de ver que exista el user
1:12:22name dentro del token y que no haya
1:12:24ninguna autenticación en el contexto de
1:12:26la aplicación no una vez que nosotros
1:12:28entramos dentro de esta validación
1:12:32como ustedes recordarán estamos
1:12:34utilizando la interfase de user detail
1:12:36service OK Para poder cargar el usuario
1:12:41por su nombre de usuario no que en este
1:12:44caso pues va a ser el email no que
1:12:47nosotros estamos enviando ahora si
1:12:50retornamos un poco a nuestra gráfica
1:12:52ustedes dirán bueno esta esta interfase
1:12:55pues está
1:12:56trayéndose directamente de la base de
1:12:59datos como lo hace Cómo utiliza jpa
1:13:01Bueno qué es lo que nos resta por hacer
1:13:03básicamente lo que nosotros tenemos que
1:13:05hacer es crear un Bing no un Bing en
1:13:09donde nosotros podamos inyectar el
1:13:11repositorio con este método que nosotros
1:13:13creamos aquí que esto ya es jpa y poder
1:13:16extraer ese usuario o en este caso ese
1:13:19email Entonces cómo hacemos eso es muy
1:13:22sencillo nosotros vamos a dirigirnos a
1:13:25Pues a nuestro paquete de config y vamos
1:13:27a crear una nueva clase que se llame
1:13:30config OK Porque aquí vamos a definir
1:13:33configuraciones de nuestra aplicación
1:13:35aunque como es de nuestra aplicación me
1:13:37gustaría llamarle app ok
1:13:41perfecto ahora qué es lo que nosotros
1:13:44vamos a definir aquí básicamente es
1:13:48primero vamos a anotar esta clase con la
1:13:51anotación de configuration para
1:13:52indicarle el contenedor de Spring que
1:13:54aquí van a ver configuraciones que deben
1:13:56ser inicializadas la anotación del
1:14:00longbook de recuerded arcos constructor
1:14:02de
1:14:03y lo que vamos a hacer primero Ok es
1:14:07crear este un método
1:14:09public que nos va a retornar un user
1:14:13detail service OK
1:14:17Y qué es lo que vamos a retornar OK
1:14:19Vamos a retornar un New user detail
1:14:23service y como pueden ver esto
1:14:25automáticamente Pues me va a permitir a
1:14:28mí
1:14:30me va a sobrecargar pues del método del
1:14:33user by user name que es el que nosotros
1:14:35estamos utilizando exactamente aquí en
1:14:39el filtro Ok entonces regresemos
1:14:42perfecto qué es lo que vamos a hacer a
1:14:46continuación Bueno sí como ven esto Se
1:14:48generó automáticamente Y si yo este
1:14:51pongo mi cursor encima de lo que estoy
1:14:53retornando puedo reemplazarlo con lambda
1:14:55para mantener Pues un código mucho más
1:14:58legible no entonces démosle clic aquí y
1:15:00como pueden ver aquí ya estoy utilizando
1:15:03expresiones Landa ahora
1:15:06voy a retornar el nombre del usuario
1:15:09pero para eso necesito inyectar mis
1:15:12repositorio Ok entonces vamos a
1:15:15inyectarlo no private final
1:15:17repository y su repositorio Ok y
1:15:20exactamente Aquí vamos a utilizar ese
1:15:23repositorio Ok user repositorio ponte
1:15:26find punto find by email que es el
1:15:31método que recordarán ustedes en el
1:15:33repositorio lo definimos aquí Ok
1:15:35entonces y le vamos a enviar en este
1:15:38caso el user me perfecto ahora
1:15:43Por qué me está dando error aquí porque
1:15:45en este caso necesito este este método
1:15:49puede fallar no Entonces en este caso
1:15:52necesita retornar una excepción Ok
1:15:56entonces vamos a colocarle orales Ok y
1:15:59Dentro de este Igual vamos a usar
1:16:01expresiones lambda y vamos a colocar
1:16:04aquí
1:16:07OK Vamos a colocar aquí que en caso de
1:16:10que no le encuentre va a lanzar un user
1:16:12name not Found exey excepción que es una
1:16:15clase netamente de Spring Security que
1:16:18pues es comúnmente usada de que el
1:16:20usuario no se ha encontrado Entonces
1:16:21vamos a arrojar esa excepción y vamos a
1:16:25indicar que el usuario no ha sido
1:16:29encontrado Okay perfecto
1:16:33muy bien
1:16:35Ok entonces bueno Vamos a darle un enter
1:16:38aquí para mantener un poco más
1:16:40legible el código Ok entonces aquí ya
1:16:44estamos utilizando bueno no no lo
1:16:46estamos utilizando un se ha definido el
1:16:48servicio Ok que nosotros estamos este
1:16:51sobrecargando en este caso pero para que
1:16:55esto pueda ser inyectado es decir este
1:16:58esto Esto puede hacer utilizado en el
1:16:59contexto de toda nuestra aplicación y
1:17:02específicamente en nuestro filtro
1:17:05tenemos que definirlo como un Bing
1:17:07entonces lo que resta por hacer es
1:17:10colocarle la notación de Pin Ok Perfecto
1:17:13entonces como ya es un Bing ya podemos
1:17:15utilizarlo en el contexto de nuestra
1:17:17aplicación y ahora sí este detail
1:17:20service básicamente va a utilizar el by
1:17:24user name
1:17:26y va a utilizar nuestro repositorio para
1:17:28poder encontrar ese usuario por su email
1:17:31perfecto
1:17:33muy
1:17:35entonces continuemos con la
1:17:37implementación
1:17:40Perfecto entonces hasta este punto si
1:17:43nosotros revisamos nuestro diagrama
1:17:44ustedes van a ver que ya el proceso está
1:17:48implementado No ya tenemos nuestro
1:17:49filtro la validación el usery service se
1:17:53actualiza el Security contex holder Ok
1:17:56esto Pues si recuerdan aquí en el filtro
1:17:58lo tenemos una vez que pues ya se hace
1:18:00el filtrado se valida el token pues se
1:18:04hace la actualización del contex holder
1:18:06Ok
1:18:07aquí
1:18:09enviándole el token de autenticación y
1:18:12se sigue el procesamiento del request
1:18:15normalmente ahora qué es lo que resta
1:18:18por hacer como ven ya tenemos
1:18:20configurado el proceso pero
1:18:23no lo estamos lanzando en ningún momento
1:18:26Ok entonces aquí tenemos que hacer ya la
1:18:30configuración de seguridad para que todo
1:18:32este proceso de Spring Security con
1:18:34Jason web token se vaya este realizando
1:18:38cómo hacemos eso bueno lo que vamos a
1:18:41hacer lo que vamos a hacer a
1:18:43continuación básicamente va a ser crear
1:18:46una nueva clase en config Ok esta la
1:18:49vamos a llamar Security Ok Recuerden que
1:18:53estamos tratando de seguir la estructura
1:18:55más fiel posible a lo que ustedes pueden
1:18:58encontrar no O sea el nombre de estas
1:19:00clases pues puede ser similar al nombre
1:19:02de clases que ustedes pueden encontrar
1:19:04en proyectos que ustedes ya hayan
1:19:07heredado no Ok entonces creamos esta
1:19:09clase Security OK Y qué vamos a definir
1:19:14bueno primero vamos a definirla con la
1:19:16notación configuration igual para
1:19:17indicar que aquí hay configuraciones y
1:19:19vamos a utilizar esta anotación muy
1:19:21importante de
1:19:24de Spring Security que es enable web
1:19:27Security Para qué me sirve enable web
1:19:30Security básicamente
1:19:32Esta bueno esta esta anotación es muy
1:19:35importante porque esta anotación permite
1:19:38definir y habilitar la seguridad a nivel
1:19:42de métodos dentro de nuestra aplicación
1:19:44no entonces Esta es muy importante
1:19:46porque con esto nosotros ya estamos
1:19:48habilitando seguridades dentro de
1:19:50nuestra red como tal Ok perfecto una vez
1:19:54entendido eso Bueno vamos a colocar la
1:19:57anotación del lombo igual de required
1:19:59arts constructor y vamos también a
1:20:02colocar la anotación enable Security Ok
1:20:05Aquí vamos a habilitar pues la seguridad
1:20:08a nivel de métodos como tal ahora
1:20:12aquí es en donde nosotros ya vamos este
1:20:15a lanzar nuestro filtro de autenticación
1:20:17de Jason webtoker para eso lo que
1:20:20tenemos que hacer es inyectar Ok de una
1:20:23vez vamos a inyectar nuestro
1:20:25web token
1:20:29filter OK Vamos a inyectarlo aquí y
1:20:32vamos a ponerlo aquí en filter OK Y qué
1:20:35es lo que vamos a hacer primero ustedes
1:20:37tal vez ya si tienen algo de experiencia
1:20:39con experiencia van a haber escuchado
1:20:41algo llamado como Security filter change
1:20:44que básicamente es una cadena de
1:20:46seguridad en donde se van ejecutando
1:20:48pues los pasos que nosotros ya
1:20:50configuramos como el filtrado la
1:20:52autenticación etcétera no Y también ya
1:20:55aquí se definen pues la seguridad es que
1:20:57nosotros le estamos dando a los a los
1:20:59netpoints que nosotros tenemos entonces
1:21:01para que funcione eso lo que tenemos que
1:21:04hacer es crear un método OK Vamos a
1:21:05colocar publics Security filter Chain ok
1:21:10vamos a colocar aquí igual Security
1:21:12filter Chain y bueno qué es lo que vamos
1:21:14a inyectar aquí básicamente es este
1:21:18objeto http Security Ok de Spring
1:21:22Security
1:21:25Perfecto entonces en base a este objeto
1:21:28que se está inyectando aquí es lo que
1:21:29nosotros vamos a trabajar entonces qué
1:21:32es lo que vamos a hacer primero primero
1:21:33vamos a colocar https security punto si
1:21:37es de http Security y bueno con los
1:21:42últimos lanzamientos los últimos
1:21:43realices de Spring Security si ustedes
1:21:46ya tienen algo de experiencia con las
1:21:48versiones anteriores ustedes recordarán
1:21:49que pues se coloca varios métodos de
1:21:52este objeto Como por ejemplo
1:21:54la otra raíz
1:22:00pero esa forma de colocar el Security
1:22:03filter change hoy en día está un poquito
1:22:05de precada no más claro está de precada
1:22:08como tal Y lo que está apuntando en los
1:22:11últimos realices es hacerlo con
1:22:13expresiones Ok entonces vamos a tratar
1:22:17de utilizar esas expresiones lambda lo
1:22:19que vamos a colocar es si es
1:22:22y vamos a colocar aquí primero
1:22:26Deshabilitar el si es OK ahora una vez
1:22:31que nosotros deshabilitamos esto vamos a
1:22:33colocar outtery auto Race http request
1:22:37Ok esto que me va a permitir aquí es
1:22:40donde yo voy a definir los redpoints de
1:22:43mi aplicación getse
1:22:46en los controladores Cuáles van a ser
1:22:49públicos y cuáles van a necesitar
1:22:51autenticación Ok entonces vamos a
1:22:54colocar aquí
1:22:56lo primero vamos a utilizar expresiones
1:22:59Landa
1:23:02y Aquí vamos a colocar un punto Aquí
1:23:06está request matters OK entonces aquí
1:23:09dentro de este método yo voy a definir
1:23:11Ok puedo colocar aquí una cadena de
1:23:15caracteres aquí se define qué en points
1:23:18de mi aplicación van a ser públicos no
1:23:20Por qué Porque aquí voy a colocar el
1:23:22método cuando yo coloco el método permit
1:23:25all básicamente estoy indicándole a
1:23:28Spring Security que todos los en points
1:23:32que yo tenga dentro de estos ricos Smash
1:23:34no van a necesitar autenticación Al
1:23:37momento de consumir Por qué ustedes
1:23:39recordarán que vamos a hacer un flujo de
1:23:40logueo Por ende nosotros vamos a
1:23:42necesitar Pues un en Point que me
1:23:45permita registrar usuarios y otro en
1:23:47Point que me permita autenticarme dentro
1:23:50de la aplicación para que me den el
1:23:51token de acceso a mi sistema Ok entonces
1:23:55esos en points no necesitan este es
1:23:59autenticación tienen que ser abiertos
1:24:01Pues de este más que nada a todo el
1:24:04público no Entonces vamos a dejarlo aquí
1:24:07con permitle ya luego vamos a crear esto
1:24:09sed points que son conocidos Como lista
1:24:11blanca no nos apresuramos entonces bueno
1:24:14colocamos permit all y lo que vamos a
1:24:16colocar aquí es también en mi request Ok
1:24:19y aquí qué es lo que estamos indicando
1:24:22básicamente que aparte de estos en
1:24:26points que yo estoy colocando aquí
1:24:26cualquier otra petición que yo realice
1:24:29en el sistema para poder ser realizar la
1:24:31performance de esa petición necesito
1:24:34estar autenticado muy bien Ahora vamos a
1:24:37ver cómo se va a administrar la sesión
1:24:39Ok y Aquí vamos igual a utilizar este
1:24:42expresiones Landa Ok entonces vamos a
1:24:45colocar 15.6 creation
1:24:48política de creación de sesiones y vamos
1:24:51a decirle que es perfecto
1:24:54una vez que nosotros indicamos esto
1:24:56vamos a tener que inyectar un
1:24:58autentication Provider un proveedor de
1:25:01autenticación Ok entonces para eso qué
1:25:04es lo que tenemos que hacer ahora lo que
1:25:07tenemos que hacer es inyectar una
1:25:09interfase después Security que se llama
1:25:11authentication
1:25:13Provider como tal autentification
1:25:16Provider Y eso va a ser lo que nosotros
1:25:18vamos a enviar aquí ahora porque este
1:25:22Por qué me está apareciendo este error
1:25:24básicamente porque esta interfase pues
1:25:26no tiene ningún Bing configurado que yo
1:25:28haya este pues previamente
1:25:34customizado no Entonces para eso nos
1:25:36vamos a ir a nuestra a la configuración
1:25:40es de nuestra aplicación y vamos a crear
1:25:42otro Bin en este caso va a ser un
1:25:45autentification
1:25:46Provider como tal Ok autentication
1:25:49Provider perfecto y Aquí vamos a ir
1:25:52colocando vamos a utilizar una Data
1:25:55Access del mismo de la misma Api de
1:25:58Spring Security Ok que es de
1:26:00autentication Provider creamos el objeto
1:26:03Volador
1:26:06OK Y qué es lo que vamos a colocar aquí
1:26:09primero vamos a indicarle el user detail
1:26:14service que nosotros estamos utilizando
1:26:16que en este caso es el de arriba no Y
1:26:18eso es Service OK Y también vamos a
1:26:21indicarle
1:26:24también el tipo de codificador de claves
1:26:27que nosotros vamos a colocar Recuerden
1:26:29que nosotros vamos a necesitar
1:26:33un bien en este caso que yo pueda este
1:26:37que me permita a mí serializar las
1:26:39claves de mi usuario
1:26:42Al momento de registrarlo no recuerden
1:26:45que no es seguro pues guardar las claves
1:26:46en su formato original sino que más bien
1:26:48hay que codificarlas y guardarlas en
1:26:50base de datos encriptadas entonces Bueno
1:26:52por el momento vamos a colocar un método
1:26:54aquí que necesitaremos que se llama
1:26:56password incoder Ok y vamos a retornar
1:27:00ese proveedor de autenticación
1:27:05perfecto
1:27:09estoy retornando la interfaz no esta
1:27:12necesito retornar el objeto que se creó
1:27:16ahí Okay perfecto muy bien entonces
1:27:19Bueno qué vamos a hacer Bueno de una vez
1:27:21completemos esto y vamos a crear el
1:27:23método de password encoder ok
1:27:27y lo que vamos a hacer aquí es
1:27:30simplemente retornar
1:27:32una clase que se llama Back password
1:27:36encoder Ok que es de Spring Security
1:27:38mismo perfecto este va a ser el objeto
1:27:42que nos va a permitir a nosotros
1:27:44serializar bueno no serializar sino más
1:27:46bien encriptar
1:27:48las claves que nosotros estemos enviando
1:27:50a registrar en nuestra base de datos
1:27:53Okay ahora muy importante siempre
1:27:55definirlo esto como bien para poder
1:27:58utilizarlo en el contexto de nuestra
1:28:00aplicación Ok perfecto
1:28:04Bueno aquí se ha colocado
1:28:06automáticamente private vamos a
1:28:08reemplazarlo por public Ok porque pues
1:28:10al ser un Big necesito utilizarlo en
1:28:12toda mi aplicación Bueno no es que
1:28:14necesite sino que así funciona entonces
1:28:17retornamos a nuestro Security config Ok
1:28:19ahí está el autentication Provider
1:28:21desapareció el error y continuamos con
1:28:23nuestra cadena de filtrado
1:28:27Perfecto entonces continuamos y una vez
1:28:30que nosotros definimos el proveedor de
1:28:31autenticación que estamos utilizando
1:28:33vamos a Añadir el filter before A qué se
1:28:37refiere esto el filtro que se va a
1:28:39ejecutar antes del proceso de
1:28:41autenticación por eso se llama add
1:28:44filter before Ok es decir este de aquí y
1:28:48cómo vamos a inyectarlo Pues básicamente
1:28:50Ya lo tenemos aquí es lo que nosotros
1:28:52mismos configuramos Vamos a ponerle aquí
1:28:56el filtro y también vamos a indicarle
1:29:01que vamos a enviarle en el filtro el
1:29:04usernameing password autentication
1:29:06filter que igual es una clase propia de
1:29:09Sprint Security perfecto ya tenemos
1:29:13configurada nuestra
1:29:16nuestra nuestra nuestra nuestra
1:29:21nuestra nuestra cadena de filtrado y
1:29:24bueno me está dando un error aquí porque
1:29:25obviamente esto posiblemente puede
1:29:27arriesgar un arrojar una excepción de
1:29:29Tal vez usuario no encontrado una
1:29:32excepción de autenticación cualquier
1:29:34tipo de excepción eso debe ser
1:29:35gestionado recuérdenlo bien ya lo vimos
1:29:37en las fases pasadas Así que vamos a
1:29:40Añadir la excepción a nuestra a la firma
1:29:43de nuestro método perfecto
1:29:45Ok Muy bien y lo que tenemos que
1:29:48retornar en este en este en este Bing en
1:29:51este caso sería ya nuestro objeto
1:29:55http Security construir perfecto y aquí
1:30:00tenemos ya nuestra cadena de seguridad
1:30:02muy importante colocarla como bien
1:30:05porque al menos Esta esta este bim tiene
1:30:09que ser ejecutado en el contexto de toda
1:30:11nuestra aplicación en el momento en el
1:30:13que se realice cualquier petición a
1:30:15nuestro servidor apirest o como ustedes
1:30:18quieran considerarlo
1:30:24muy bien Ok ahora ya tenemos definida
1:30:29pues nuestra nuestra cadena de
1:30:33de filtrado OK Que va a ser la
1:30:36responsable de lanzar nuestro filtro
1:30:38antes del proceso de autenticación
1:30:41Entonces qué es lo que tenemos que hacer
1:30:45ahora como mencioné vamos a necesitar
1:30:49proveerle a nuestro cliente una Api
1:30:52primero para poderse registrar en la
1:30:54aplicación en este caso y segundo para
1:30:57poderse
1:30:59para poder autenticarse dentro de
1:31:02nuestra aplicación y poder en este caso
1:31:04acceder a las urls protegidas como puede
1:31:08ser por ejemplo greating controller que
1:31:10pues después de esta configuración ya va
1:31:13a ser una URL protegida y que a
1:31:15diferencia del inicio ya no nos va a
1:31:17retornar sin autenticación el Hello from
1:31:19apijacks Ok entonces cómo vamos a hacer
1:31:23eso Bueno vamos a tener primero que
1:31:24crear un nuevo controlador ok
1:31:29vamos a crear un autentication
1:31:32controller
1:31:37autentication otorrisation control
1:31:42out controller
1:31:45out controller dejémoslo en out
1:31:48controller OK ahora vamos a colocar las
1:31:51siguientes anotaciones lo primero que
1:31:52vamos a hacer es definirlo como un redes
1:31:55controller Ok Nada nuevo Vamos a ponerle
1:31:58un request mapping ok En este caso vamos
1:32:00a como estábamos manejando el estándar
1:32:03no teníamos Api greating en este caso
1:32:05Vamos a ponerle
1:32:08Vamos a ponerle Api
1:32:14OK Sí out Y pues el recuerdo
1:32:21perfecto ahora
1:32:24vamos a tener que inyectar un servicio
1:32:28pero primero vamos a definirlos en
1:32:30points de una de una vez Ok entonces
1:32:32vamos a ponerlo en public vamos a
1:32:35utilizar en este caso response Ok que
1:32:39pertenece Pues a Spring framework como
1:32:42tal que es una entidad que nos permite
1:32:45pues gestionar los las los resultados
1:32:47http Ok como siempre pues en estos
1:32:51cursos Vamos a aprender siempre cositas
1:32:52nuevas que les pueden servir ya depende
1:32:54de ustedes cómo utilizan las
1:32:56herramientas que se les proporciona Ok
1:32:58entonces vamos a tener que retornar
1:33:03un un una una respuesta de autenticación
1:33:08no Entonces tenemos que crear igual una
1:33:11un modelo una deto como ustedes quieran
1:33:13llamarlo Dentro de este dentro de esta
1:33:16de esta petición Así que vamos a dejarle
1:33:19el nombre por el momento por ahí y vamos
1:33:21a decir que este es el método de
1:33:22registro Okay
1:33:24perfecto entonces cuando yo quiero
1:33:27registrar qué es lo que voy a recibir
1:33:30como petición obviamente voy a recibir
1:33:33la
1:33:36la en este caso voy a recibir
1:33:39el modelo de de registro no como tal
1:33:44Okay entonces para eso vamos a colocar
1:33:47aquí la anotación request
1:33:50request Body Ok me van a enviar en la
1:33:53petición
1:33:56un objeto tipo register request
1:34:00vamos a llamarle así sí vamos ese va a
1:34:04ser el nombre del modelo y vamos a
1:34:06ponerle request como tal Ok esto ya lo
1:34:08vamos a ir creando paulatinamente Y qué
1:34:10es lo que vamos a retornar en este caso
1:34:12sería un response entity OK indicando
1:34:15que todo fue un Ok Ok como un estatus Ok
1:34:18y vamos a tener que en este caso
1:34:21inyectar un servicio en donde yo
1:34:24configure la autenticación es decir en
1:34:27donde se realiza el proceso de
1:34:29registrado o el proceso de autenticación
1:34:32Así que vamos a indicarle que en este
1:34:34caso sería una especie de out service OK
1:34:39Y que debe tener un método igual que se
1:34:41llama register en donde vamos a enviarle
1:34:44pues la petición como tal Ok Perfecto
1:34:48entonces este en Point lo vamos a
1:34:51colocar como post mapping ok
1:34:54va a ser un post porque obviamente estoy
1:34:56enviando un cuerpo en la petición y va a
1:34:59tener el en Point de register Ok y De
1:35:03igual forma vamos a necesitar
1:35:05uno para autenticación Ok entonces vamos
1:35:08a llamarle auténtica Kate
1:35:12autenticate igual nos va a devolver una
1:35:15response de autenticación en este caso
1:35:17no se va a llamar register en este caso
1:35:19se va a llamar igual autenticate y no
1:35:22vamos a recibir un
1:35:25registro sino que más bien Vamos a
1:35:28recibir una petición de autenticación
1:35:30Entonces vamos a crear ese
1:35:33ese modelo como tal también Ok entonces
1:35:37colocamos aquí request perfecto
1:35:41y en el out service va a haber un método
1:35:44llamado authenticate
1:35:46en donde va a ir igual el rico es que
1:35:48estamos mandando perfecto
1:35:51muy bien entonces por el momento tenemos
1:35:53nuestro controlador Ok hemos creado dos
1:35:56en points uno para registrarse otro para
1:35:58autenticarse Y qué es lo que tenemos que
1:36:00hacer ahora primero vamos a tener que
1:36:03crear el los modelos no entonces bueno
1:36:06para tener ordenado nuestro trabajo
1:36:08vamos a crear Dentro de este paquete
1:36:10otro paquete que lo vamos a llamar
1:36:12models OK y dentro de esta de estos
1:36:15models vamos a crear una clase que se
1:36:18llame
1:36:20autentication request
1:36:27autentication request
1:36:30que es la que tenemos aquí
1:36:32vamos a igual a crear otra clase que se
1:36:36llame register request
1:36:42perfecto Muy bien Entonces ahora sí que
1:36:45ya tenemos esto por lo menos vamos a
1:36:47quitar estos errores sin importar la
1:36:49clase y vamos a importar la clase
1:36:50perfecto
1:36:53y nos falta el out response Ok entonces
1:36:56vamos a crear una clase que se llama
1:36:58igual
1:37:01out response
1:37:06perfecto De igual forma vamos a
1:37:08importarla ahí no Uy uy uy uy uy uy
1:37:11response si se llama así al responder
1:37:20models Ok veamos
1:37:28out
1:37:30response OK Me faltó la s aquí Me faltó
1:37:35la s acá
1:37:37Perfecto entonces vamos ahora sí importa
1:37:40las clases y ya lo atendemos Muy bien
1:37:43Entonces qué estructura van a tener esto
1:37:45bueno en la petición de autenticación
1:37:48básicamente va a recibir el email y la
1:37:52clave no Entonces vamos a colocar aquí
1:37:54por private String email Ok y private
1:37:59String password Ok para poderse
1:38:03autenticar pues es como un login no me
1:38:05vas a mandar tu usuario y tu contraseña
1:38:06en este caso el usuario es el email OK
1:38:09Vamos a colocar las anotaciones Data
1:38:11vamos a colocar el patrón builder como
1:38:14siempre el norx constructor y el all
1:38:19arts constructor perfecto
1:38:21ahora la petición de registro qué es lo
1:38:26que va a tener bueno Generalmente pues
1:38:28obviamente me tiene que mandar la mayor
1:38:29cantidad de datos que que solicita la
1:38:33entidad no que en este caso es usuario
1:38:36bueno el ID no me lo pide se genera
1:38:38automáticamente así que pues van a ser
1:38:41el primer nombre el segundo nombre el
1:38:43email la clave y el rol Tampoco porque
1:38:46vamos a hacer que se asigne
1:38:48automáticamente el rol
1:38:50Ok entonces vamos a ir al registro vamos
1:38:54a colocar estos
1:38:56atributos de aquí perfecto muy bien y De
1:38:59igual forma las mismas anotaciones del
1:39:02autentication request Ok Recuerden que
1:39:04esto está funcionando como dt o models
1:39:06como ustedes quieran llamarle pues para
1:39:08mantener una mayor efectividad en la
1:39:11gestión de datos Okay muy bien y qué es
1:39:15lo que vamos a responder básicamente
1:39:16Pues nosotros vamos a responder con el
1:39:19token no una vez que te registras te voy
1:39:22a devolver un token Y si te autenticas
1:39:24igual te voy a devolver el token que
1:39:26pues nuestra misma Api está generando y
1:39:29De igual forma Aquí vamos a colocar las
1:39:32anotaciones de una dto que en este caso
1:39:36sería Data perfecto
1:39:40OK Así que ya estamos preparados con
1:39:44nuestras modelos con nuestro controlador
1:39:48lo que resta por hacer es hacer la
1:39:51implementación de el servicio de
1:39:54autenticación
1:40:01Perfecto entonces ya estamos listos con
1:40:03nuestros controladores para registro y
1:40:05autenticación de nuestro sistema qué es
1:40:09lo que vamos a hacer a continuación
1:40:11Bueno vamos a crear el servicio de
1:40:13autenticación Bueno me estoy dando
1:40:15cuenta que pues no cree como tal un
1:40:18paquete de servicio y de hecho pues
1:40:21en esta clase de aquí debería haber
1:40:24sido colocada en ese paquete Pero bueno
1:40:27no la vamos a tocar vamos a dejarla ahí
1:40:29y ahora sí voy a crear ese paquete de
1:40:32Service
1:40:34y vamos a crear una interfase Ok que en
1:40:38este caso sería
1:40:42en este caso sería
1:40:45out service Me parece que así fue que se
1:40:49le colocó a ver
1:40:51[Música]
1:40:53porque una clase en donde vamos a
1:40:55definir Pues en este caso qué es lo que
1:40:57vamos a hacer vamos a necesitar un
1:40:59método que sea public out
1:41:03autentification como out response
1:41:08síster Ok que va a recibir un registro
1:41:17Ok y vamos a tener igual un Bueno aquí
1:41:21no sería público Ok y vamos a igual un
1:41:25out response
1:41:27pero en este caso
1:41:35en este caso va a ser de
1:41:45Vamos a continuar sería en este caso de
1:41:48autenticate
1:41:52y no voy a recibir un registro
1:41:55indication request perfecto ya ahora
1:42:00bien qué es lo que vamos a hacer pues
1:42:02vamos a inyectar esa
1:42:05en este caso Esa esa interfase no que se
1:42:08va a llamar
1:42:09private out
1:42:15service out service y listo hemos
1:42:19inyectado ese servicio como tal OK Vamos
1:42:22a colocarlo aquí el auto whited que
1:42:25hemos venido utilizando
1:42:32Ok y es porque porque no hay esos bings
1:42:35porque tenemos que crear nuestra clase
1:42:37de implementación que en este caso de
1:42:40out service implementation Ok perfecto
1:42:44vamos a anotar aquí con service como tal
1:42:47Ok y pues acuérdense que nosotros
1:42:52hacemos la implementación de la interfaz
1:42:55Ok implemento implementamos los métodos
1:42:58aquí tenemos sobrecargados ambos métodos
1:43:01como tal Y pues se soluciona el problema
1:43:04ese Ahora sí empezamos con la
1:43:06implementación de esta lógica no Ok
1:43:10Perfecto entonces empecemos primero por
1:43:14inyectar el repositorio de nuestro
1:43:16usuario Ok entonces vamos a hacer lo
1:43:19siguiente
1:43:23repository Ok y yo soy repository en
1:43:26este caso como no estoy haciendo uso de
1:43:28la natación vamos a colocar igual
1:43:30required
1:43:33arts constructor y así nos libramos de
1:43:35esos problemas OK Y qué es lo que vamos
1:43:38a hacer
1:43:40Dentro de este método vamos a colocar
1:43:42aquí
1:43:44bar usuario va a ser igual a usuario
1:43:47punto builder OK Vamos igual First name
1:43:52request punto get First name muy bien
1:43:56punto
1:44:01vamos a colocar el email Ok email
1:44:05request punto Gmail Ok y aquí viene algo
1:44:09que ya hicimos que es el password como
1:44:13mencioné el password jamás debe
1:44:15guardarse Pues en sus caracteres
1:44:17originales en base de datos si ustedes
1:44:20recuerdan Pues nosotros aquí en el up
1:44:22config definimos este Bing como tal
1:44:24password encoder Entonces vamos a
1:44:27inyectar este Bin dentro de la
1:44:29implementación de nuestro servicio
1:44:31sería private final igual password
1:44:35encoder Ok password encoder y vamos a
1:44:39colocarlo Aquí vamos a utilizar password
1:44:41encoder punto codificar y vamos a enviar
1:44:44nuestra clave ok get password perfecto
1:44:47el rol como dije Vamos a ponerlo
1:44:50nosotros por defecto esto ya depende de
1:44:52los requerimientos de la aplicación de
1:44:54ustedes pues ya verán Cómo adaptan la
1:44:58lógica de esta implementación Pues a su
1:45:00sistema Pero vamos a colocarlo en este
1:45:03caso por defecto como un usuario no y
1:45:06vamos finalmente a hacer buil de este
1:45:08objeto muy bien
1:45:10Vamos a guardar este usuario
1:45:13y punto
1:45:17y enviamos el user
1:45:19muy bien guardamos el usuario
1:45:22y vamos a generar el token recuerden yo
1:45:26hago un registro y cuando me registro
1:45:27pues obviamente le devuelvo un token a
1:45:29ese a ese usuario para que pueda acceder
1:45:32a los recursos no Entonces vamos a igual
1:45:35utilizar
1:45:36jwt
1:45:39token OK y vamos a para generar el el
1:45:44Jason web token que vamos a necesitar
1:45:47Bueno pues vamos a utilizar nuestro
1:45:50servicio de
1:45:51Jason web token para poder generar el
1:45:55token como tal OK Vamos a utilizar este
1:45:57método de aquí Entonces vamos a colocar
1:46:00aquí
1:46:02bueno primero vamos a inyectar como tal
1:46:04ese ese
1:46:06servicio no private final Igual vamos a
1:46:10colocar un jbl service
1:46:14perfecto y aquí sí vamos a utilizar
1:46:19toque no vamos a utilizar el del sino
1:46:22siempre a base del
1:46:25y le mandamos el usuario perfecto Por
1:46:28qué este usuario porque este objeto
1:46:29usuario pues puede hacerlo porque si
1:46:32recuerdan pues la entidad está
1:46:33implementando user deateles muy bien
1:46:36entonces regresamos a nuestra
1:46:38implementación
1:46:39generamos el token y vamos a retornar
1:46:42nuestra autentication
1:46:45Ah No perdón era out response
1:46:49OK Vamos a colocar punto builder Ok y
1:46:53vamos a ponerle el token en este caso va
1:46:57a ser el jw punto
1:47:01perfecto ya hemos acabado con el proceso
1:47:03de registro para recapitular que estamos
1:47:06haciendo básicamente
1:47:08creamos nuestro objeto usuario guardamos
1:47:11la clave guardamos su rol Ok la clave
1:47:15está haciendo encriptada utilizamos el
1:47:17repositorio que estamos inyectando como
1:47:19tal Ok y después pues simplemente lo que
1:47:22estamos haciendo es
1:47:24utilizar nuestro nuestro servicio de
1:47:27Jason web token para generar el token
1:47:30después del registro del usuario Ok y le
1:47:33devolvemos ese token a nuestro cliente
1:47:34perfecto
1:47:37ahora lo que vamos a hacer es el proceso
1:47:40de autenticación
1:47:45muy bien Ok entonces ya hemos bueno
1:47:51configurado Bueno no pero programado la
1:47:54implementación del método en nuestro en
1:47:59nuestro servicio de out service Ok
1:48:01entonces ahora vamos a programar la
1:48:05parte de autenticación de nuestro
1:48:07usuario Ok entonces para eso lo que
1:48:10vamos a hacer es lo siguiente primero
1:48:12vamos a tener que inyectar Ok inyectar
1:48:15una interfase de Sprint Security
1:48:17conocida como authentication manager
1:48:20para eso vamos a hacerlo entonces sería
1:48:22Okay minúsculas private final
1:48:26autentification
1:48:28manager Ok y le vamos a colocar aquí
1:48:31como autentification manager perfecto
1:48:33ahora por qué me asomo este error pues
1:48:35efectivamente lo que tenemos que hacer
1:48:38es ir a nuestra clase de configuraciones
1:48:40y crear ese bim como tal Ok entonces
1:48:43vamos a hacerlo vamos a public
1:48:47autentication manager Ok
1:48:50autentication manager y vamos aquí a
1:48:53colocar Bueno a inyectar no la clase
1:48:56autentication
1:48:58configuration como tal colocamos Aquí
1:49:01vamos a dejarlo en conflict Ok perfecto
1:49:04y qué es lo que vamos a retornar Bueno
1:49:06vamos a utilizar config punto get
1:49:09authentication manager perfecto
1:49:12básicamente pues es una es una
1:49:17una una clase que nos permite a nosotros
1:49:20gestionar la autenticación mediante las
1:49:23credenciales que nosotros le enviemos
1:49:25como request para poder autenticarnos es
1:49:28decir enviamos el usuario el password y
1:49:30nos autenticamos antes lo que queríamos
1:49:32hacer era registrarnos ahora lo que
1:49:34queremos hacer es autenticar ahora
1:49:36porque me asomé el error porque falta
1:49:37agregar excepcional a la firma de
1:49:40nuestro método que entonces agregamos el
1:49:42exception Y como siempre colocamos esto
1:49:45como un Bin para poderlo usar en el
1:49:47contexto de nuestra aplicación
1:49:48regresamos a nuestra implementación Y lo
1:49:51que vamos a hacer es lo siguiente como
1:49:54tal vamos a
1:49:57a vamos a realizar la autenticación
1:50:02utilizando la interfase que Nosotros
1:50:04acabamos de colocar como un bi entonces
1:50:06utilizamos el autentication manager Ok
1:50:10punto autenticate OK Y qué es lo que
1:50:14vamos a mandar aquí en autenticate un
1:50:15nuevo objeto name password autentication
1:50:19token y Aquí vamos a colocar el request
1:50:23punto Ok get email y el request punto
1:50:27get password Ok perfecto
1:50:30listo Una vez que se ha realizado la
1:50:33autenticación lo que vamos a hacer es
1:50:35encontrar este usuario por su email
1:50:37Entonces vamos a colocar igualla y usar
1:50:41repository punto find user by email Ok
1:50:45request punto get email punto punto Y si
1:50:51no pues va a lanzar una excepción OK
1:50:54ahora ustedes me dirán bueno por ahí
1:50:57puede haber una especie de confusión no
1:50:59porque estoy buscando el email en la
1:51:02base de datos otra vez Bueno aquí lo que
1:51:04estoy haciendo es autenticar Ok si se
1:51:08autentica quiere decir que el Jason web
1:51:10token fue correcto Y ahora yo voy a
1:51:12tomar ese email Ok y lo estoy tomando
1:51:15directamente de base de datos a ver si
1:51:17es que lo encuentro para construir el
1:51:20token para poderle dar permisos al
1:51:24cliente que acaba de enviar la petición
1:51:26ok No es para nada seguro el mismo
1:51:28email de la petición para poder
1:51:30construir el token es mucho mejor
1:51:32el email del usuario directamente de la
1:51:36base de datos después de que este se
1:51:38haya autenticado entonces obviamente
1:51:40tenemos que encontrar una coincidencia
1:51:42entre el email que están enviando con el
1:51:45que se encuentra en la base de datos
1:51:46Recuerden que estamos utilizando el
1:51:48email como el nombre de usuario o como
1:51:49un identificador único de este usuario
1:51:52en la base de datos Ok Perfecto entonces
1:51:55como ya en teoría hasta este punto se
1:51:58encuentra el usuario lo que vamos a
1:52:00hacer es un construir nuestro Jason web
1:52:03token Ok para poderle dar acceso a
1:52:06nuestra aplicación cliente Así que vamos
1:52:08a utilizar nuestro servicio y vamos a
1:52:11generar el token OK Y qué es lo que
1:52:13vamos a enviar el usuario perfecto
1:52:16muy bien Ahora sí vamos a retornar Ok
1:52:21nuestro autentication
1:52:24response Así fue como le colocamos no
1:52:28era out response
1:52:31Ok punto builder punto token y le
1:52:36enviamos nuestro toque Ok y construimos
1:52:39el objeto y ya se está retornando OK
1:52:42borramos este que está de más perfecto y
1:52:45ya tenemos nuestro servicio de registro
1:52:48y autenticación de usuarios como tal
1:52:56perfecto muchachos ya estamos llegando a
1:52:59la parte final Ok de esta fase del curso
1:53:03ya esto prácticamente está listo para
1:53:06probarse Pero si ustedes recuerdan yo
1:53:09mencioné algo de unas whites no O
1:53:11También conocido como listas blancas a
1:53:14qué me refiero con listas blancas no son
1:53:16más que los den points que se pueden
1:53:17exponer a cualquier usuario sin
1:53:20necesidad de ser autenticado y
1:53:21autorizado dentro de la aplicación Ok
1:53:24entonces me gustaría realizar primero
1:53:27esa lista blanca y para ello voy a ir al
1:53:30controlador de grating Ok si ustedes
1:53:32recuerdan Este es el primer el primer en
1:53:34Point que nosotros creamos y me gustaría
1:53:37evidenciar ya el funcionamiento de
1:53:39Sprint Security como tal no Entonces
1:53:41vamos a crear otro en Point pero que se
1:53:44va a llamarse Hello protect Ok haciendo
1:53:47referencia a que este en Point está
1:53:49protegido por Spring Security y este
1:53:51quiero exponerlo pues a todo a todo tipo
1:53:54de usuario no y vamos voy a colocar aquí
1:53:57un mensaje de Hello from jacks protected
1:53:59perfecto vamos a cambiar el nombre del
1:54:01método protector muy bien listo en
1:54:05esencia tienen el mismo funcionamiento
1:54:07vamos a guardar esto y también vamos a
1:54:09ir a nuestra clase de Security config Ok
1:54:13y vamos a crear nosotros esta llamada
1:54:15lista Blanca entonces para eso Bueno lo
1:54:20que yo comúnmente utilizo hay diferentes
1:54:22formas de crear esta lista yo lo que voy
1:54:23a hacer es crear un método privado Ok
1:54:26request que se que me traiga un rico
1:54:28smatcher Ok y esto lo voy a llamar como
1:54:32public en points o en points públicos o
1:54:36como ustedes le quieran Llamar al final
1:54:37es lo mismo No y este método me va a
1:54:41traer un nuevo objeto
1:54:45por request matcher Ok y esto puede
1:54:49traerme una colección Pues de diferentes
1:54:53de diferentes en points que yo quiera
1:54:56hacer los públicos No aquí voy a colocar
1:54:58New and pad request matcher Ok y aquí yo
1:55:02voy a colocar pues la URL que en este
1:55:04caso va a ser pública no Perfecto
1:55:07entonces aquí qué es lo que vamos a
1:55:09vamos a
1:55:12la dirección url de nuestra Api pública
1:55:16En este caso OK Vamos a ponerle ese
1:55:18Hello public OK Para que no haya ninguna
1:55:22ninguna confusión Entonces vamos a
1:55:25copiar a big rating OK Vamos a Security
1:55:29config lo colocamos aquí es leash y
1:55:31vamos a nuestro controlador greating Ok
1:55:34y copiamos 6 Hello pública muy bien
1:55:37perfecto vamos a colocarlo aquí y listo
1:55:40entonces si yo ahorita guardo ok
1:55:45y levanto mi aplicación que veamos el
1:55:48Run cómo está ejecutándose
1:55:50perfecto una de Las observaciones que
1:55:53podemos nosotros ya ir viendo es que si
1:55:56ustedes recuerdan al inicio pues
1:55:57generaba automáticamente el password no
1:56:00O sea había una password que protegía
1:56:02los enpoints ya no se genera Pues que
1:56:05porque nosotros ya hemos realizado
1:56:07nuestras propias configuraciones de
1:56:08Sprint Security Ok eso como primero
1:56:11ahora yo ya tengo preparado aquí en
1:56:14postman
1:56:16esa petición Ok entonces si yo coloco
1:56:19aquí 6 Hello protected ok
1:56:23no perdón 6 Hello public primero
1:56:29see Hello public Ok Déjenme
1:56:33verting controles say hello publique
1:56:39Déjenme revisarlo por aquí hubo un
1:56:42pequeño error vamos aquí a Security
1:56:45Ok dice que la URL es Api greeting
1:56:506 Hello public
1:56:55greeting
1:56:576 Hello pública Ok revisamos la consola
1:57:02vamos a enviar ok Ya sé qué es lo que
1:57:06está sucediendo un error mío errores de
1:57:10humanos y es que claro estoy creando los
1:57:12los points pero pues no los estoy no les
1:57:16estoy dando los permisos acá Ok entonces
1:57:18bueno reemplazamos de eso voy a dejar
1:57:20este error ahí en video para que lo vean
1:57:23Porque puede llegar a pasar vamos a
1:57:25detener nuestra aplicación Ok guardamos
1:57:27cambios ejecutamos de nuevo Ok veamos
1:57:31que nuestra aplicación se ejecute de
1:57:33forma correcta
1:57:35Ok
1:57:36perfecto
1:57:38se ha inicializado y ahora sí vamos a
1:57:41probar de nuevo y miren ahora sí me
1:57:43devuelve el Hello from a pictures OK
1:57:46Pero si yo en este momento por ejemplo
1:57:49quiero testear mi controlador y quiero
1:57:53ya no quiero public sino protect ustedes
1:57:56van a ver que por defecto OK Vamos a
1:57:59reemplazar esto Aquí vamos a colocar 6
1:58:02Hello protector ustedes van a ver que me
1:58:05da un estatus 403 forbidden OK Porque
1:58:09porque pues si ustedes recuerdan en el
1:58:12Security yo mencioné que Bueno aparte de
1:58:16los publiques en points voy a permitir a
1:58:18todos acceder a ellos cualquier otra
1:58:21petición que se realice al servidor debe
1:58:23ser autenticada para poder acceder a ese
1:58:26recurso Entonces en este aspecto
1:58:29nosotros ya vemos y hemos este
1:58:33configurado nuestra aplicación para que
1:58:35proteja Ok las peticiones que están
1:58:38entrando dentro del servidor y está
1:58:41solicitando que primero tenga que ser
1:58:42autenticado es por eso que nos regresa
1:58:44nuestro estatus 403 forbidden Ok
1:58:48perfecto ahora vamos a Ahora sí a probar
1:58:53nuestro controlador de registro y
1:58:58autenticación
1:59:02Ok entonces vamos a probar nuestros en
1:59:06points tanto de registro como de
1:59:08autenticación Ok de nuestro nuestros
1:59:12usuarios Ok entonces yo ya tengo
1:59:14preparado aquí en nuestra herramienta
1:59:16postman Ok
1:59:17ambas peticiones lo primero que vamos a
1:59:21hacer es registrar un usuario Ok First
1:59:23name Last email y password son los
1:59:25campos que yo pues requiero en esta
1:59:28petición porque es lo que me está
1:59:30pidiendo Recuerden el modelo me pide
1:59:31esos cuatro Campos
1:59:34Ok entonces vamos a enviar esta petición
1:59:38y miren me acaba de dar un forbile OK Y
1:59:42si ustedes recuerdan obviamente Esto se
1:59:45está dando Porque yo aún no he colocado
1:59:47este estas urls como públicas no
1:59:50Entonces voy a copiar este pad de aquí
1:59:53OK Porque como quiero que ambas ureles o
1:59:56sea es decir todo el control controlador
1:59:58sea público voy a copiar este pack de
2:00:01aquí Ok y vamos a crear un nuevo
2:00:05antpad request matcher Ok y vamos a
2:00:09colocar ese pack y le vamos a dar un
2:00:11Slash asterisco asterisco indicando que
2:00:15todo el controlador va a ser público es
2:00:17decir todas las peticiones como pueden
2:00:19ver aquí tanto teticaria y registro van
2:00:21a ser públicas en cambio acá simplemente
2:00:23pues estoy haciendo referencia a una URL
2:00:27en específico en este caso a todo un
2:00:29controlador como tal Ok perfecto
2:00:32guardamos los cambios le tenemos la
2:00:35aplicación vamos vamos a inicializar de
2:00:39nuevo nuestra aplicación Ok
2:00:42y vamos a ver cómo se comporta nuestra
2:00:45full con Spring Security y Jason web
2:00:49tokens Ok entonces vamos a ir a nuestro
2:00:54postman y ahora sí vamos a
2:00:57registrar a nuestro usuario
2:01:01perfecto y miren ahora sí me devuelve un
2:01:04estatus 200 Ok junto con un token
2:01:08generado por mí misma aplicación
2:01:13Ok junto con un toque generado por
2:01:17mi aplicación Ok entonces antes de
2:01:19seguir probando vamos a ver qué
2:01:21información contiene este token como tal
2:01:24vamos a ir a nuestra página Jason web
2:01:27token punto y vamos a pegarlo Ok y miren
2:01:31lo primero que encontramos es el
2:01:33algoritmo con el que nosotros pues este
2:01:35configuramos el Jason web token que es
2:01:38el hs
2:01:39256 Ok qué más tenemos de información el
2:01:43subjet que en este caso es el email que
2:01:45estamos utilizando como identificador
2:01:47único para poder poder
2:01:50autenticarse o loguearse dentro de
2:01:52nuestra aplicación Ok y miren También
2:01:54tenemos la fecha de emisión de este
2:01:58token que es el bueno a la fecha de hoy
2:02:01sería el 16 de julio del 2023 hora
2:02:04Ecuador a las 8:48 de la noche OK y
2:02:09veamos la fecha de expiración que
2:02:10Esperamos que sea pues de 24 horas la la
2:02:14diferencia de expiración no Ok y se va a
2:02:18caducar a él Ah no perdón no es sábado
2:02:20es domingo Ah ya el domingo y se va a
2:02:23caducar el domingo a las 9 de la noche
2:02:26okay Aquí hubo un error al parecer
2:02:28Estamos dándole solo una hora de
2:02:30diferencia vamos a ir a nuestro código
2:02:33Ok y vamos a irnos a nuestro servicio
2:02:37Aquí es donde configuramos a ver mi
2:02:40segundo 60 Segundos Okay okay Me faltó
2:02:44agregarle los 60 minutos que tiene una
2:02:47hora y ahí sí ya estaría como una
2:02:49diferencia de un día Ok estos valores
2:02:51pues ustedes los pueden acomodar a como
2:02:53ustedes quieran si quieren pues pueden
2:02:55darle solo 15 minutos de de de tiempo de
2:03:00expiración al toque no 10 minutos o en
2:03:02este caso un día o meses ya depende de
2:03:05ustedes cuánto tiempo quieran darle no
2:03:07en este caso pues vamos a utilizar un
2:03:10día de diferencia Ok entonces vamos a
2:03:14parar la aplicación guardar nuestros
2:03:17cambios OK Vamos a correr de nuevo la
2:03:20aplicación
2:03:25perfecto
2:03:28muy bien
2:03:30Se ha inicializado la aplicación y en
2:03:33este caso pues vamos a cambiar el nombre
2:03:35ok vamos a poner yo que sé John doe OK
2:03:40Para que haya dos usuarios John doe en
2:03:42este caso va a ser John arroba
2:03:44ejemplo.com igual la misma contraseña y
2:03:48vamos a registrarlo
2:03:50Ahora sí nos devuelve igual un token y
2:03:53veamos qué es lo que contiene este token
2:03:54vamos a reemplazar este de aquí por el
2:03:57nuevo y miren Bueno ahí está el usuario
2:04:00está la fecha de emisión que es el 16 de
2:04:04Julio un domingo a las 8:51 de la noche
2:04:07y la fecha de caducidad que ahora sí es
2:04:10del lunes 17 de 17 de julio del 2023 a
2:04:16las 8:51 de la noche Aquí sí ya tenemos
2:04:17una diferencia de 24 horas qué más
2:04:20podemos ver pues la firma hmac 256 que
2:04:24si ustedes recuerdan pues lo hicimos con
2:04:26nuestra clase Kiss Ok entonces Esta es
2:04:29la información de nuestro Jason web
2:04:31token que nosotros hemos configurado
2:04:35ahora qué es lo que vamos a hacer vamos
2:04:37a probar que efectivamente este token a
2:04:40mí me esté dando permisos para acceder a
2:04:43la información pero antes que nada vamos
2:04:45a ir a nuestra base de datos hagamos un
2:04:47Select y miren Aquí están los dos
2:04:49usuarios registrados bueno que acabamos
2:04:51de registrar okay Y qué es lo que
2:04:54podemos ver nosotros aquí por ejemplo
2:04:57podemos ver el email el primer nombre el
2:05:01apellido y también podemos ver como las
2:05:03claves han sido encriptadas no entonces
2:05:06Beck password de de
2:05:10bueno la clase B password es la que
2:05:13responsable de haber encriptado esto y
2:05:15esto obviamente pues es una práctica
2:05:18ya ni siquiera buena práctica sino una
2:05:21práctica obligatoria que en una base de
2:05:23datos estén encriptadas las las
2:05:25contraseñas no OK Y tenemos los roles
2:05:28que están en cero y cero si ustedes
2:05:29recuerdan pues este estamos manejandolo
2:05:32con Index a los roles No si nosotros
2:05:34vamos pues a nuestro
2:05:36proyecto vamos a ir a nuestro user y
2:05:39vamos y Recuerden que pues nosotros
2:05:41estamos utilizando un enumerado de tipo
2:05:45ordinal Entonces se va a manejar con
2:05:47órdenes no entonces por eso el rol está
2:05:50en cero porque ambos son usuarios
2:05:51comunes y corrientes OK ahora vamos a
2:05:56probar el token que nos en el registro
2:05:58Ok entonces copiamos este token y ahora
2:06:02quiero este bueno como ustedes pueden
2:06:04ver pues está prohibido el acceso a
2:06:07Hello protect porque no he enviado
2:06:09ninguna nada en mi cabecera de
2:06:11autorización Entonces ahora vamos a ir
2:06:13autorización y vamos a elegir bitter
2:06:16token como tal Ok entonces pues
2:06:18obviamente está configuración de postman
2:06:20automáticamente va a mandar beatter un
2:06:22espacio y lo que nosotros peguemos en el
2:06:25token aquí directamente
2:06:27Entonces si nosotros enviamos esto miren
2:06:30ya me retorna un Hello from apijacks
2:06:33protected y con este token ya puedo
2:06:35acceder a este recurso que en un inicio
2:06:38estaba protegido vamos a validar otra
2:06:41cosa vamos a cambiar algo del token
2:06:43vamos a agregarle yo que sé una de y una
2:06:46G Al final para comprobar que este token
2:06:49ya no es auténtico Es decir ya no es un
2:06:51token generado por nosotros y De igual
2:06:54forma estoy enviando una autorización y
2:06:55un toque vamos a ver si con la
2:06:57modificación nos deja igual acceder a
2:06:59este recurso Y de nuevo Nos está dando
2:07:02un estatus forbidden como tal Ok
2:07:06entonces hemos comprobado que en la
2:07:10petición de registro el registro de un
2:07:13usuario la encriptación de la contraseña
2:07:14y el token que nos retorna es totalmente
2:07:17válido Por lo cual el proceso de
2:07:21autenticación bueno el proceso de
2:07:23registro y autenticación con el token
2:07:26está perfectamente bien Ahora vamos a
2:07:30probar que la petición de autenticación
2:07:33efectivamente funcione no Ya me registré
2:07:36como usuario me dio un token ahora
2:07:37suponiendo que yo ya tengo un usuario
2:07:40como tal
2:07:41ok En este caso vamos a utilizar el
2:07:44nuevo usuario que era John
2:07:46arroba ejemplo no como podemos ver si
2:07:49nosotros vamos a la base de datos era
2:07:51John arroba ejemplo.com Ok y vamos a
2:07:54utilizar la clave con la que se registró
2:07:56recuerden uno dos tres cuatro cinco seis
2:07:58es una clave netamente de ejemplo y
2:08:00vamos a enviarlo vamos a ver qué es lo
2:08:02que sucede perfecto se autentico
2:08:05perfectamente bien ok se hizo login me
2:08:08devolvió un token de acceso Ok si
2:08:11nosotros volvemos aquí a nuestra
2:08:12herramienta jwt punto io vamos a ver qué
2:08:16tiene la información Ok y la fecha de
2:08:19expedición y de expiración de este token
2:08:22perfecto muy bien Ahora vamos a ver si
2:08:23este token no sirve para Acceder al
2:08:25recurso protegido que en este caso sería
2:08:27saludar 6 Hello projected Ok enviamos el
2:08:32token y miren perfectamente me devuelve
2:08:35el Hello from Api jacks project Ok
2:08:39Perfecto entonces hasta este punto ya
2:08:43hemos nosotros desarrollado e
2:08:46implementado Sprint Security con Jason
2:08:51web tokens
2:08:54muy bien Qué les ha parecido esta
2:08:56tercera fase del curso desarrollo web
2:08:58con Spring Boot Espero que les haya
2:09:00gustado Spring Security con Jason web
2:09:02tokens Yo sé que pues hay una gama de
2:09:05frameworks este increíble no dentro de
2:09:07Spring que se pueden integrar está el
2:09:09protocolo autos.0 y pues bueno varias
2:09:13herramientas más pero yo creo que Spring
2:09:15Security con Jason web tokens son un
2:09:18buen Punto de partida para la gente que
2:09:19está empezando Pues en este framework no
2:09:21se preocupen iremos sacando más
2:09:23contenido de desarrollo en el canal
2:09:27espérenlo y ya se les dirá avisando poco
2:09:31a poco no se olviden también de
2:09:32seguirnos de nuestro Instagram y bueno
2:09:33me queda felicitarles y agradecerles a
2:09:36la gente que ha llegado hasta este punto
2:09:38del curso que ha estado comentando
2:09:40dejando un like compartiendo
2:09:41suscribiéndose al Canal porque de esa
2:09:43forma nos posicionan a jax Pues con el
2:09:46algoritmo de YouTube y nos recomiendan
2:09:48más y nos ayuda a crecer mucho más OK
2:09:50entonces sin enrollarme mucho más
2:09:53agradecer todos Y de nuevo volverles a
2:09:56recomendar que por favor dejen un like
2:09:57Comenten se suscriban compartan Este
2:10:00vídeo para llegar a mucha más gente y
2:10:01así hacer crecer más de esta comunidad
2:10:03de este canal que ahorita está pequeña
2:10:05pero ya consistente Y también decirles
2:10:09que no no me he olvidado de leerlos en
2:10:11los comentarios y ya he visto a gente
2:10:13que quiere que realicemos un proyecto
2:10:15tal vez integrando algunos de estos
2:10:17conocimientos
2:10:19posiblemente lo hagamos ya lo estaremos
2:10:22realizando en un futuro espérennos que
2:10:24vamos a tener mucho más contenido Así
2:10:26que yo me despido esto es Jacques Mi
2:10:29nombre es Alex y nos estaremos viendo
2:10:30hasta la próxima
2:10:32[Música]

About this transcript

This page contains the full transcript of Spring Security | Implementando Spring Security + JWT by JAAX, generated from the public captions YouTube serves with the video. The transcript has 18,399 words across 2,854 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.