Swagger + Springdoc OpenAPI + Spring Boot: Cómo asegurar el punto de extremo de definición API.

Answer

1. 

   davy.ai

   June 17, 2023 at 12:22 pm

   Sí, es posible asegurar el punto de acceso de definición de API al que se accede mediante Swagger UI utilizando un token JWT.

   Para hacerlo, necesitas configurar tu aplicación Spring Boot para usar Spring Security y definir las reglas de seguridad apropiadas. Luego, puedes actualizar la configuración de tu Swagger UI para incluir el token JWT en las cabeceras de la solicitud al recuperar la definición de la API.

   Aquí están los pasos para hacer esto:

   1. Agrega dependencias de Spring Security a tu proyecto:

   <dependency>
       <groupid>org.springframework.boot</groupid>
       <artifactid>spring-boot-starter-security</artifactid>
   </dependency>
   

   1. Configura Spring Security para asegurar tu API REST:

   @Configuration
   @EnableWebSecurity
   public class SecurityConfig extends WebSecurityConfigurerAdapter {
   
       @Override
       protected void configure(HttpSecurity http) throws Exception {
           http.authorizeRequests()
               .antMatchers("/api/**").authenticated()
               .and()
               .oauth2ResourceServer()
               .jwt();
       }
   }
   

   Esta configuración asegura todas las solicitudes al camino “/api” y sus subcaminos, y requiere que se presente un token JWT válido en las cabeceras de la solicitud.

   1. Actualiza la configuración de tu Swagger UI para incluir el token JWT en las cabeceras de la solicitud:

   @Configuration
   public class SwaggerConfig {
   
       @Value("${spring.security.oauth2.resourceserver.jwt.issuer-uri}")
       private String issuerUri;
   
       @Bean
       public SecurityConfiguration security() {
           return SecurityConfigurationBuilder.builder()
               .clientId("your-client-id")
               .clientSecret("your-client-secret")
               .realm("your-realm")
               .appName("your-app-name")
               .scopeSeparator(",")
               .useBasicAuthenticationWithAccessCodeGrant(true)
               .build();
       }
   
       @Bean
       public OpenAPI customOpenAPI() {
           return new OpenAPI()
               .components(new Components().addSecuritySchemes("bearer-jwt",
                   new SecurityScheme().type(SecurityScheme.Type.HTTP).scheme("bearer").bearerFormat("JWT")))
               .info(new Info()
                   .title("Your API")
                   .version("1.0.0")
                   .description("Your API description"))
               .addSecurityItem(new SecurityRequirement().addList("bearer-jwt", "read,write"))
               .paths(new Paths()
                   .addPathItem("/api/**",
                       new PathItem().get(new Operation()
                           .security(Arrays.asList(new SecurityRequirement()
                               .addList("bearer-jwt", "read,write")))
                           .responses(new ApiResponses()
                               .addApiResponse("200", new ApiResponse()
                                   .description("OK")))))));
       }
   
       @Bean
       public GroupedOpenApi customApi() {
           return GroupedOpenApi.builder()
               .group("custom-api")
               .packagesToScan("com.example.api")
               .pathsToMatch("/api/**")
               .build()
               .addOpenApiCustomiser(openApi -> {
                   OAuthFlows flows = new OAuthFlows();
                   flows.authorizationCode(new OAuthFlow()
                       .authorizationUrl(issuerUri + "/protocol/openid-connect/auth")
                       .tokenUrl(issuerUri + "/protocol/openid-connect/token")
                       .scopes(new Scopes().addString("read", "Read access")
                           .addString("write", "Write access")));
   
                   openApi.getComponents()
                       .putSecuritySchemes("bearer-jwt", new SecurityScheme()
                           .type(SecurityScheme.Type.OAUTH2)
                           .flows(flows)
                           .bearerFormat("JWT"));
               });
       }
   }
   

   Esta configuración define un grupo de OpenAPI personalizado y agrega requisitos de seguridad a él, usando el esquema “bearer-jwt” definido anteriormente. El Swagger UI ahora incluirá un botón “Autorizar” con el campo de entrada de token apropiado, y usará el token JWT para recuperar la definición de la API.

   Con estos cambios, tanto el acceso como la visualización de tu API REST estarán asegurados utilizando un token JWT.

Comments are closed.