¿Cómo crear usuarios personalizados en Spring Security?
Crear usuarios personalizados en Spring Security es una práctica esencial para adaptarse a los requisitos de seguridad específicos de una aplicación. En lugar de utilizar usuarios generados automáticamente por el framework, se pueden definir usuarios en memoria que se personalicen según sea necesario. A continuación, exploraremos cómo implementar esto paso a paso.
¿Cómo implementar UserDetailService?
Para empezar, debemos crear nuestra propia implementación de UserDetailsService. Este servicio es fundamental para gestionar la autenticación de usuarios en Spring Security.
Declarar el método: Primero, se crea un método público que retorne un UserDetailsService.
Crear usuarios en memoria: Utilizando el builder proporcionado por Spring, se construye un usuario, por ejemplo:
@Bean public UserDetailsService memoryUsers() { UserDetails admin = User.builder() .username("admin") .password("admin") .roles("ADMIN") .build(); return new InMemoryUserDetailsManager(admin); }
En el ejemplo, hemos creado un usuario administrador llamado "admin" con contraseña "admin".
¿Cómo configurar y codificar contraseñas?
Uso de Password Encoder
Para mantener la seguridad de las contraseñas, es crucial utilizar un PasswordEncoder. Spring recomienda usar algoritmos como bcrypt que ofrecen mayor protección.
Implementar un Password Encoder: Se crea un PasswordEncoder y se lo anota como un @Bean para que Spring lo administre.
@Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); }
Codificar la contraseña: Se utiliza el PasswordEncoder para codificar y almacenar la contraseña.
String encodedPassword = passwordEncoder().encode("admin");
¿Cómo probar la autenticación personalizada con Postman?
Una vez configurados los usuarios y el encoder, se puede proceder a verificar la autenticación a través de herramientas como Postman.
Configurar autenticación básica: En Postman, establece la autenticación básica usando el usuario "admin" y contraseña "admin".
Ejecutar pruebas: Al iniciar la aplicación y realizar peticiones autenticadas a servicios protegidos, se debe recibir un código 200 si todos los detalles coinciden.
¿Qué errores comunes pueden surgir?
PasswordEncoder no definido: Si surge un error de falta de PasswordEncoder, asegúrate de que esté configurado adecuadamente y anotado en Spring.
Contraseña incorrecta: Un código 401 indica un error en la autenticación. Revisa que tanto usuario como contraseña sean precisos y estén codificados correctamente.
Al implementar estos pasos, has creado exitosamente usuarios personalizados en Spring y asegurado que las contraseñas se manejen con cifrado seguro. ¡Continúa explorando y personalizando más funciones de Spring Security! En la próxima lección, aprenderás a gestionar permisos para distintos roles de usuario. ¡No te lo pierdas!
Crear usuarios personalizados en Spring Security es una práctica esencial para adaptarse a los requisitos de seguridad específicos de una aplicación. En lugar de utilizar usuarios generados automáticamente por el framework, se pueden definir usuarios en memoria que se personalicen según sea necesario. A continuación, exploraremos cómo implementar esto paso a paso.
Para empezar, debemos crear nuestra propia implementación de UserDetailsService. Este servicio es fundamental para gestionar la autenticación de usuarios en Spring Security.
Declarar el método: Primero, se crea un método público que retorne un UserDetailsService.
Crear usuarios en memoria: Utilizando el builder proporcionado por Spring, se construye un usuario, por ejemplo:
@Bean
public UserDetailsService memoryUsers() {
UserDetails admin = User.builder()
.username("admin")
.password("admin")
.roles("ADMIN")
.build();
return new InMemoryUserDetailsManager(admin);
}
En el ejemplo, hemos creado un usuario administrador llamado "admin" con contraseña "admin".
Para mantener la seguridad de las contraseñas, es crucial utilizar un PasswordEncoder. Spring recomienda usar algoritmos como bcrypt que ofrecen mayor protección.
Implementar un Password Encoder: Se crea un PasswordEncoder y se lo anota como un @Bean para que Spring lo administre.
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
Codificar la contraseña: Se utiliza el PasswordEncoder para codificar y almacenar la contraseña.
String encodedPassword = passwordEncoder().encode("admin");
Una vez configurados los usuarios y el encoder, se puede proceder a verificar la autenticación a través de herramientas como Postman.
Configurar autenticación básica: En Postman, establece la autenticación básica usando el usuario "admin" y contraseña "admin".
Ejecutar pruebas: Al iniciar la aplicación y realizar peticiones autenticadas a servicios protegidos, se debe recibir un código 200 si todos los detalles coinciden.
PasswordEncoder no definido: Si surge un error de falta de PasswordEncoder, asegúrate de que esté configurado adecuadamente y anotado en Spring.
Contraseña incorrecta: Un código 401 indica un error en la autenticación. Revisa que tanto usuario como contraseña sean precisos y estén codificados correctamente.
Al implementar estos pasos, has creado exitosamente usuarios personalizados en Spring y asegurado que las contraseñas se manejen con cifrado seguro. ¡Continúa explorando y personalizando más funciones de Spring Security! En la próxima lección, aprenderás a gestionar permisos para distintos roles de usuario. ¡No te lo pierdas!
Si alguno han llegado hasta aqui, y tienen el "inconveniente" de algunas partes del codigo 'deprecated' no es que sea asi tal cual.
Es que la version que estamos usando desde el cursop de JPA de Spring es 3.0.8 como máximo, en ese se usó 3.0.6. Entonces cuandoalgunos dicenq ue aparce deprecado es porque no se tomaron la moelstia de escuchar al profe en ese entonces y usaron una version superior.
Gracias por su atención
@Bean
public UserDetailsService memoryUsers(){
UserDetails admin = User.builder()
.username("admin")
.password(passwordEncoder().encode("admin"))
.roles("ADMIN")
.build();
return new InMemoryUserDetailsManager(admin);
}
@Bean
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
El curso requiere una actualización urgente. Hay métodos que usan prácticas deprecadas, y lo ideal es enseñar con las últimas indicaciones y las mejores prácticas.
Desde acá debo decir que me emociono y la forma de Alejo enseñar es lo mejor, esperando con ansias los JWT <3
Estoy de acuerdo con lo que se habla, es necesario estar en la versión correspondiente al curso, pero profes. también es necesario actualizar el curso en especial cuando ya van varias versiones por encima de la que se elaboro el curso, esto con el fin de continuar manteniendo la buena calidad de este curso y una buena experiencia para los que apenas arriban a Spring Security.
Excelente curso.
Para crear autenticación en memoria en Spring Security, se debe implementar un User Details Service que retorne un UserDetailsManager. Se declara un usuario en memoria utilizando el User del core de Spring Security. Es recomendable usar bcrypt para codificar la contraseña. Luego, se anota el método de configuración con @Bean para que Spring lo reconozca. Este proceso permite autenticar usuarios personalizados en tu aplicación, facilitando la gestión de roles y permisos.
package com.platzi.pizzeria.web.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.csrf(AbstractHttpConfigurer::disable)
.cors(Customizer.withDefaults())
.authorizeHttpRequests((authorize) -> authorize.requestMatchers(HttpMethod.GET, "/api/pizzas/**").permitAll()
.requestMatchers(HttpMethod.PUT).denyAll()
.anyRequest()
.authenticated()
)
.httpBasic(Customizer.withDefaults())
;
return http.build();
}
@Bean
public InMemoryUserDetailsManager memoryUsers() {
UserDetails admin = User.builder()
.username("admin")
.password(passwordEncoder().encode("admin"))
.roles("ADMIN")
.build();
return new InMemoryUserDetailsManager(admin);
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
mi app es una version 3.2.0 y el mentodo 3.2.0 lo cree tal cual y no tube problemas de compilacion.
✅