सभी को नमस्कार!

इस लेख में, मैं स्प्रिंग वेबफ्लक्स, स्प्रिंग सिक्योरिटी, स्प्रिंग क्लाउड नेटफ्लिक्स यूरेका (सर्विस डिस्कवरी), हिस्ट्रिक्स (सर्किट ब्रेकर), रिबन (क्लाइंट साइड लोड बैलेंसर), बाहरी कॉन्फ़िगरेशन (गिट रिपॉजिटरी के माध्यम से) का उपयोग करके रिएक्टिव रिस्टफुल मिक्सर सेवाओं को बनाने के लिए बुनियादी घटकों का प्रदर्शन करूंगा। , स्प्रिंग क्लाउड स्लीथ, स्प्रिंग क्लाउड गेटवे, स्प्रिंग बूट रिएक्टिव मोंगोबीडी। साथ ही निगरानी के लिए स्प्रिंग बूट एडमिन और जिपकिन।

यह समीक्षा प्रतिक्रियात्मक अनुप्रयोगों के लिए एक्शन और हैंड्स-ऑन स्प्रिंग 5 सिक्योरिटी में स्प्रिंग माइक्रोसर्विसेस की पुस्तकों का अध्ययन करने के बाद की गई थी।

इस लेख में, हम तीन प्रश्नों के साथ एक प्राथमिक अनुप्रयोग बनाएंगे: खेल की एक सूची प्राप्त करें, खिलाड़ियों की एक सूची प्राप्त करें, खिलाड़ियों की आईडी से एक गेम बनाएं, जवाब के लिए एक लंबे इंतजार के मामले में रोलबैक (हिस्ट्रिक्स कमबैक) की जांच करने का अनुरोध। और प्रतिक्रियाशील अनुप्रयोगों के लिए पुस्तक हैंड्स-ऑन स्प्रिंग 5 सिक्योरिटी के आधार पर जेडब्ल्यूटी टोकन के माध्यम से प्रमाणीकरण का कार्यान्वयन।

मैं यह वर्णन नहीं करूंगा कि आईडीई में प्रत्येक एप्लिकेशन कैसे बनाया जाता है, क्योंकि यह लेख एक अनुभवी उपयोगकर्ता के लिए है।

परियोजना की संरचना

परियोजना में दो मॉड्यूल शामिल हैं। spring-servers मॉड्यूल को प्रोजेक्ट से प्रोजेक्ट में सुरक्षित रूप से कॉपी किया जा सकता है। लगभग कोई कोड और कॉन्फ़िगरेशन नहीं हैं। tictactoe-services मॉड्यूल में हमारे एप्लिकेशन के मॉड्यूल और माइक्रोसर्विस शामिल हैं। मैं तुरंत नोटिस करूंगा कि सेवाओं में auth-module और domain-module को जोड़ते हुए, मैं माइक्रोसर्विस आर्किटेक्चर के सिद्धांतों में से एक का उल्लंघन करता हूं। लेकिन इन मॉड्यूल को विकसित करने के स्तर पर, मेरा मानना ​​है कि यह सबसे इष्टतम समाधान है।

ग्रेड विन्यास

मुझे पसंद है जब पूरा ग्रैडल कॉन्फ़िगरेशन एक फ़ाइल में है, इसलिए मैंने पूरी परियोजना को एक build.gradle में कॉन्फ़िगर किया है।

 buildscript { ext { springBootVersion = '2.1.1.RELEASE' gradleDockerVersion = '0.20.1' } repositories { mavenCentral() maven { url "https://plugins.gradle.org/m2/" } } dependencies { classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") classpath("gradle.plugin.com.palantir.gradle.docker:gradle-docker:${gradleDockerVersion}") } } allprojects { group = 'com.tictactoe' apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' apply plugin: 'io.spring.dependency-management' apply plugin: 'com.palantir.docker' apply plugin: 'com.palantir.docker-run' apply plugin: 'com.palantir.docker-compose' } docker.name = 'com.tictactoe' bootJar.enabled = false sourceCompatibility = 11 repositories { mavenCentral() maven { url "https://repo.spring.io/milestone" } } subprojects { ext['springCloudVersion'] = 'Greenwich.M3' sourceSets.configureEach { sourceSet -> tasks.named(sourceSet.compileJavaTaskName, { options.annotationProcessorGeneratedSourcesDirectory = file("$buildDir/generated/sources/annotationProcessor/java/${sourceSet.name}") }) } repositories { mavenCentral() maven { url "https://repo.spring.io/milestone" } } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}" } } dependencies { compile fileTree(include: ['*.jar'], dir: 'libs') compileOnly('org.projectlombok:lombok') annotationProcessor('org.projectlombok:lombok') } } project(':spring-servers') { bootJar.enabled = false task cleanAll { dependsOn subprojects*.tasks*.findByName('clean') } task buildAll { dependsOn subprojects*.tasks*.findByName('build') } dockerCompose { template 'docker-compose.spring-servers.template.yml' dockerComposeFile 'docker-compose.spring-servers.yml' } } project(':tictactoe-services') { bootJar.enabled = false task cleanAll { dependsOn subprojects*.tasks*.findByName('clean') } task buildAll { dependsOn subprojects*.tasks*.findByName('build') } } // Tictactoe Modules project(':tictactoe-services:domain-module') { bootJar.enabled = false jar { enabled = true group 'com.tictactoe' baseName = 'domain-module' version = '1.0' } dependencies { implementation('org.springframework.boot:spring-boot-starter-security') implementation('org.springframework.boot:spring-boot-starter-data-mongodb-reactive') implementation('org.springframework.boot:spring-boot-starter-validation') implementation('com.fasterxml.jackson.core:jackson-annotations:2.9.3') implementation 'com.intellij:annotations:+@jar' compileOnly('org.projectlombok:lombok') testCompile group: 'junit', name: 'junit', version: '4.12' } } project(':tictactoe-services:auth-module') { bootJar.enabled = false jar { enabled = true baseName = 'auth-module' version = '1.0' } dependencies { implementation project(':tictactoe-services:domain-module') implementation('org.springframework.boot:spring-boot-starter-webflux') implementation('org.springframework.boot:spring-boot-starter-data-mongodb-reactive') implementation('org.springframework.boot:spring-boot-starter-security') implementation('org.springframework.cloud:spring-cloud-starter-netflix-ribbon') implementation('org.springframework.security:spring-security-oauth2-core') implementation('org.springframework.security:spring-security-oauth2-jose') implementation 'com.intellij:annotations:+@jar' testImplementation('org.springframework.boot:spring-boot-starter-test') testImplementation('io.projectreactor:reactor-test') testImplementation('org.springframework.security:spring-security-test') } } project(':tictactoe-services:user-service') { bootJar { launchScript() baseName = 'user-service' version = '0.1.0' } dependencies { implementation project(':tictactoe-services:domain-module') implementation project(':tictactoe-services:auth-module') } } project(':tictactoe-services:game-service') { bootJar { launchScript() baseName = 'game-service' version = '0.1.0' } dependencies { implementation project(':tictactoe-services:domain-module') implementation project(':tictactoe-services:auth-module') } } project(':tictactoe-services:webapi-service') { bootJar { launchScript() baseName = 'webapi-service' version = '0.1.0' } dependencies { implementation project(':tictactoe-services:domain-module') implementation project(':tictactoe-services:auth-module') } } // Spring Servers project(':spring-servers:discovery-server') { bootJar { launchScript() baseName = 'discovery-server' version = '0.1.0' } dependencies { implementation('org.springframework.cloud:spring-cloud-starter-netflix-eureka-server') implementation('org.springframework.boot:spring-boot-starter-security') compile('javax.xml.bind:jaxb-api:2.3.0') compile('javax.activation:activation:1.1') compile('org.glassfish.jaxb:jaxb-runtime:2.3.0') testImplementation('org.springframework.boot:spring-boot-starter-test') } } project(':spring-servers:config-server') { bootJar { launchScript() baseName = 'config-server' version = '0.1.0' } dependencies { implementation('org.springframework.boot:spring-boot-starter-security') implementation('org.springframework.cloud:spring-cloud-config-server') implementation('org.springframework.cloud:spring-cloud-starter-config') implementation('org.springframework.cloud:spring-cloud-starter-netflix-eureka-client') testImplementation('org.springframework.boot:spring-boot-starter-test') } } project(':spring-servers:gateway-server') { bootJar { launchScript() baseName = 'gateway-server' version = '0.1.0' } dependencies { implementation('org.springframework.boot:spring-boot-starter-webflux') implementation('org.springframework.boot:spring-boot-starter-actuator') implementation('org.springframework.cloud:spring-cloud-starter-gateway') implementation('org.springframework.cloud:spring-cloud-starter-config') implementation('org.springframework.cloud:spring-cloud-starter-netflix-ribbon') implementation('org.springframework.cloud:spring-cloud-starter-netflix-eureka-client') testImplementation('org.springframework.boot:spring-boot-starter-test') } } project(':spring-servers:admin-server') { ext['springBootAdminVersion'] = '2.1.1' bootJar { launchScript() baseName = 'admin-server' version = '0.1.0' } dependencies { implementation('org.springframework.boot:spring-boot-starter-web') implementation('org.springframework.boot:spring-boot-starter-security') implementation('de.codecentric:spring-boot-admin-starter-server') implementation('org.springframework.cloud:spring-cloud-starter-config') implementation('org.springframework.cloud:spring-cloud-starter-netflix-eureka-client') testImplementation('org.springframework.boot:spring-boot-starter-test') testImplementation('org.springframework.security:spring-security-test') } dependencyManagement { imports { mavenBom "de.codecentric:spring-boot-admin-dependencies:${springBootAdminVersion}" } } } subprojects { subproject -> if (file("${subproject.projectDir}/docker/Dockerfile").exists()) { docker { // workingbit - replace with your dockerhub's username name "workingbit/${subproject.group}.${subproject.bootJar.baseName}" tags 'latest' dockerfile file("${subproject.projectDir}/docker/Dockerfile") files tasks.bootJar.archivePath, 'docker/run.sh' buildArgs "JAR_FILE": "${subproject.bootJar.baseName}-${subproject.bootJar.version}.jar", "RUN_SH": "run.sh" } } else { docker.name = 'noop' } if (subproject.name.endsWith('service')) { dependencies { implementation('org.springframework.boot:spring-boot-starter-actuator') implementation('org.springframework.boot:spring-boot-starter-webflux') implementation('org.springframework.boot:spring-boot-starter-data-mongodb-reactive') implementation('org.springframework.boot:spring-boot-starter-security') implementation('org.springframework.security:spring-security-oauth2-core') implementation('org.springframework.security:spring-security-oauth2-jose') implementation('org.springframework.cloud:spring-cloud-starter-config') implementation('org.springframework.cloud:spring-cloud-starter-netflix-eureka-client') implementation('org.springframework.cloud:spring-cloud-starter-netflix-hystrix') implementation('org.springframework.cloud:spring-cloud-starter-netflix-ribbon') implementation('org.springframework.cloud:spring-cloud-starter-sleuth') implementation('org.springframework.cloud:spring-cloud-starter-zipkin') implementation('org.springframework.security:spring-security-rsa') implementation('com.intellij:annotations:+@jar') implementation('org.apache.commons:commons-lang3:3.8.1') runtimeOnly('org.springframework.boot:spring-boot-devtools') testImplementation('org.springframework.boot:spring-boot-starter-test') testImplementation('de.flapdoodle.embed:de.flapdoodle.embed.mongo') testImplementation('io.projectreactor:reactor-test') } } } 

एक कॉमन कॉन्फ़िगरेशन फ़ाइल का उपयोग करने से आप माइक्रोसेवर्स के लिए निर्भरता को सामान्य बना सकते हैं, इस मामले में सेवाओं को "सेवा" में समाप्त होने वाले नाम के साथ, एक ही स्थान पर। लेकिन, यह फिर से माइक्रोसर्विस की स्वायत्तता के सिद्धांत का उल्लंघन करता है। सामान्य निर्भरता के अलावा, आप कार्यों को उपप्रोजेक्ट में जोड़ सकते हैं। मैंने gradle.plugin.com.palantir.gradle.docker:gradle-docker जोड़ gradle.plugin.com.palantir.gradle.docker:gradle-docker साथ काम करने के लिए gradle.plugin.com.palantir.gradle.docker:gradle-docker प्लगइन कार्य।

प्रमाणीकरण मॉड्यूल मॉड्यूल

अब, JWT प्रमाणीकरण मॉड्यूल पर विचार करें। इस मॉड्यूल के auth पैकेज का विवरण प्रतिक्रियात्मक प्रमाणीकरण पुस्तक में पाया जा सकता है जिसका मैंने ऊपर उल्लेख किया है।

आह, config अधिक विस्तार से config पैकेज पर ध्यान config ।

"जटिल" गुणों का वर्ग ApplicationClientsProperties.java

 @Data @Component @ConfigurationProperties("appclients") public class ApplicationClientsProperties { private List<ApplicationClient> clients = new ArrayList<>(); @Data public static class ApplicationClient { private String username; private String password; private String[] roles; } } 

इस वर्ग में इनमेरी डेटाबेस कॉन्फ़िगरेशन के लिए "जटिल" गुण हैं।

AuthModuleConfig.java मॉड्यूल कॉन्फ़िगरेशन क्लास

 @Data @Configuration @PropertySource("classpath:moduleConfig.yml") public class AuthModuleConfig { @Value("${tokenExpirationMinutes:60}") private Integer tokenExpirationMinutes; @Value("${tokenIssuer:workingbit-example.com}") private String tokenIssuer; @Value("${tokenSecret:secret}") // length minimum 256 bites private String tokenSecret; } 

संसाधन फ़ाइल में, आपको इन चरों को निर्दिष्ट करना होगा। मेरे कॉन्फ़िगरेशन में, टोकन 10 घंटे के बाद मृत हो जाता है।

MicroserviceServiceJwtAuthWebFilter.java फ़िल्टर मैचर्स कॉन्फ़िगरेशन क्लास

 public class MicroserviceServiceJwtAuthWebFilter extends JwtAuthWebFilter { private final String[] matchersStrings; public MicroserviceServiceJwtAuthWebFilter(JwtService jwtService, String[] matchersStrings) { super(jwtService); this.matchersStrings = matchersStrings; } @Override protected ServerWebExchangeMatcher getAuthMatcher() { List<ServerWebExchangeMatcher> matchers = Arrays.stream(this.matchersStrings) .map(PathPatternParserServerWebExchangeMatcher::new) .collect(Collectors.toList()); return ServerWebExchangeMatchers.matchers(new OrServerWebExchangeMatcher(matchers)); } } 

निर्माण के दौरान, यह फ़िल्टर JWT के साथ काम करने के लिए सेवा को पारित करता है और उन रास्तों की सूची है जो यह फ़िल्टर प्रक्रिया करेगा।

रिएक्टिव स्प्रिंग बूट सिक्योरिटी माइक्रोसर्विसस्पायरिंगसिटीवेबफ्लक्सकॉन्फिग.जवा कॉन्फ़िगरेशन क्लास

 @ConditionalOnProperty(value = "microservice", havingValue = "true") @EnableReactiveMethodSecurity @PropertySource(value = "classpath:/application.properties") public class MicroserviceSpringSecurityWebFluxConfig { @Value("${whiteListedAuthUrls}") private String[] whiteListedAuthUrls; @Value("${jwtTokenMatchUrls}") private String[] jwtTokenMatchUrls; /** * Bean which configures whiteListed and JWT filter urls * Also it configures authentication for Actuator. Actuator takes configured AuthenticationManager automatically * which uses MapReactiveUserDetailsService to configure inMemory users */ @Bean public SecurityWebFilterChain springSecurityFilterChain( ServerHttpSecurity http, JwtService jwtService ) { MicroserviceServiceJwtAuthWebFilter userServiceJwtAuthWebFilter = new MicroserviceServiceJwtAuthWebFilter(jwtService, jwtTokenMatchUrls); http.csrf().disable(); http .authorizeExchange() .pathMatchers(whiteListedAuthUrls) .permitAll() .and() .authorizeExchange() .pathMatchers("/actuator/**").hasRole("SYSTEM") .and() .httpBasic() .and() .addFilterAt(userServiceJwtAuthWebFilter, SecurityWebFiltersOrder.AUTHENTICATION); return http.build(); } } 

यहां तीन दिलचस्प एनोटेशन हैं।

 @ConditionalOnProperty(value = "microservice", havingValue = "true") 

एक एनोटेशन जो इस मॉड्यूल को कनेक्ट करता है जो कॉन्फ़िगरेशन फ़ाइल में माइक्रोसर्वर चर पर निर्भर करता है जो एनोटेशन में निर्दिष्ट होता है। कुछ मॉड्यूल में सामान्य टोकन चेकिंग को अक्षम करने के लिए यह आवश्यक है। इस एप्लिकेशन में, यह webapi-service , जिसका स्वयं का SecurityWebFilterChain कार्यान्वयन webapi-service बीन।

 @PropertySource(value = "classpath:/application.properties") 

यह एनोटेशन आपको मुख्य सेवा से गुण लेने की अनुमति देता है जिसमें यह मॉड्यूल आयात किया जाता है। दूसरे शब्दों में, चर

 @Value("${whiteListedAuthUrls}") private String[] whiteListedAuthUrls; @Value("${jwtTokenMatchUrls}") private String[] jwtTokenMatchUrls; 

उनके मूल्यों को वंश के माइक्रोसर्विस कॉन्फ़िगरेशन से लें।

और, एक एनोटेशन जो आपको @PreAuthorize(“hasRole('MY_ROLE')”) जैसे सुरक्षा एनोटेशन को लटकाने की अनुमति देता है

 @EnableReactiveMethodSecurity 

और इस मॉड्यूल में, SecurityWebFilterChain बीन बनाई जाती है, जो एक्ट्यूएटर तक पहुँच को कॉन्फ़िगर करती है, अनुमति दी गई url और url जिस पर JWT टोकन चेक किया गया है। यह ध्यान दिया जाना चाहिए कि JWT टोकन फ़िल्टर तक पहुंच आवश्यक है।

SpringWebFluxConfig.java कॉन्फ़िगरेशन

इस कॉन्फ़िगरेशन में, MapReactiveUserDetailsService को एक्ट्यूएटर और अन्य सिस्टम उपयोगकर्ताओं को स्मृति में कॉन्फ़िगर करने के लिए बनाया जाता है।

 @Bean @Primary public MapReactiveUserDetailsService userDetailsRepositoryInMemory() { List<UserDetails> users = applicationClients.getClients() .stream() .map(applicationClient -> User.builder() .username(applicationClient.getUsername()) .password(passwordEncoder().encode(applicationClient.getPassword())) .roles(applicationClient.getRoles()).build()) .collect(toList()); return new MapReactiveUserDetailsService(users); } 

ReactiveUserDetailsService जो Spring Security साथ हमारे उपयोगकर्ता भंडार को सिलाई के लिए आवश्यक है।

 @Bean public ReactiveUserDetailsService userDetailsRepository(UserRepository users) { return (email) -> users.findByEmail(email).cast(UserDetails.class); } 

प्रतिक्रियाशील अनुरोध करने के लिए एक WebClient क्लाइंट बनाने के लिए एक बीन।

 @Bean public WebClient loadBalancedWebClientBuilder(JwtService jwtService) { return WebClient.builder() .filter(lbFunction) .filter(authorizationFilter(jwtService)) .build(); } private ExchangeFilterFunction authorizationFilter(JwtService jwtService) { return ExchangeFilterFunction .ofRequestProcessor(clientRequest -> ReactiveSecurityContextHolder.getContext() .map(securityContext -> ClientRequest.from(clientRequest) .header(HttpHeaders.AUTHORIZATION, jwtService.getHttpAuthHeaderValue(securityContext.getAuthentication())) .build())); } 

निर्माण के दौरान, दो फ़िल्टर जोड़े जाते हैं। LoadBalancer और एक फ़िल्टर जो ReactiveSecurityContext संदर्भ से एक Authentication उदाहरण लेता है और इससे एक टोकन बनाता है ताकि लक्ष्य सर्वर इसे प्रमाणित करता है और तदनुसार अधिकृत करता है।

और MongoDB ObjectId प्रकार और दिनांक के साथ काम करने की सुविधा के लिए, मैंने एक ऑब्जेक्टमैपर निर्माण बिन जोड़ा:

 @Bean @Primary ObjectMapper objectMapper() { Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder(); builder.serializerByType(ObjectId.class, new ToStringSerializer()); builder.deserializerByType(ObjectId.class, new JsonDeserializer() { @Override public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { Map oid = p.readValueAs(Map.class); return new ObjectId( (Integer) oid.get("timestamp"), (Integer) oid.get("machineIdentifier"), ((Integer) oid.get("processIdentifier")).shortValue(), (Integer) oid.get("counter")); } }); builder.featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); return builder.build(); } 

Microservice खेल-सेवा

Microservice खेल-सेवा में निम्नलिखित संरचना है:

जैसा कि आप इसमें देख सकते हैं, केवल एक ApplicationConfig कॉन्फ़िगरेशन फ़ाइल

विन्यासक ApplicationConfig.java

 @Data @Configuration @EnableReactiveMongoRepositories("com.tictactoe.gameservice.repository") @Import({ApplicationClientsProperties.class, SpringWebFluxConfig.class, MicroserviceSpringSecurityWebFluxConfig.class}) public class ApplicationConfig { @Value("${userserviceUrl}") private String userServiceUrl; } 

इसमें user-service के पते के साथ एक चर है और दो दिलचस्प एनोटेशन हैं:

 @EnableReactiveMongoRepositories("com.tictactoe.gameservice.repository") 

इस एनोटेशन को कॉन्फ़िगरेशनकर्ता को MongoDB रिपॉजिटरी को इंगित करना आवश्यक है।

 @Import({ApplicationClientsProperties.class, SpringWebFluxConfig.class, MicroserviceSpringSecurityWebFluxConfig.class}) 

यह एनोटेशन auth-module से कॉन्फ़िगरेशन आयात करता है।

GameService.java सेवा

इस सेवा में केवल निम्नलिखित दिलचस्प कोड हैं:

 @HystrixCommand public Flux<Game> getAllGames() { return gameRepository.findAll(); } @HystrixCommand(fallbackMethod = "buildFallbackAllGames", threadPoolKey = "licenseByOrgThreadPool", threadPoolProperties = {@HystrixProperty(name = "coreSize", value = "30"), @HystrixProperty(name = "maxQueueSize", value = "10")}, commandProperties = { @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"), @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "75"), @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "7000"), @HystrixProperty(name = "metrics.rollingStats.timeInMilliseconds", value = "15000"), @HystrixProperty(name = "metrics.rollingStats.numBuckets", value = "5")} ) public Flux<Game> getAllGamesLong() { // logger.debug("LicenseService.getLicensesByOrg Correlation id: {}", UserContextHolder.getContext().getCorrelationId()); randomlyRunLong(); return gameRepository.findAll(); } 

यह विधि बेतरतीब ढंग से एक अपवाद फेंकता है और एनस्ट्रेशन के अनुसार हिस्ट्रिक्स निम्न विधि का परिणाम देता है:

 private Flux<Game> buildFallbackAllGames() { User fakeUserBlack = new User("fakeUserBlack", "password", Collections.emptyList()); User fakeUserWhite = new User("fakeUserBlack", "password", Collections.emptyList()); Game game = new Game(fakeUserBlack, fakeUserWhite); List<Game> games = List.of(game); return Flux.fromIterable(games); } 

जैसा कि ऊपर उल्लिखित पुस्तक में कहा गया है, अगर कुछ टूटा हुआ है, तो चलो कैश्ड या वैकल्पिक डेटा को कुछ नहीं से बेहतर दिखाते हैं।

माइक्रो सर्विस वेबपई-सेवा

यह गेटवे और आंतरिक microservices के बीच का एक प्रकार का मिडलवेयर है जो बाहर से दिखाई नहीं देता है। इस सेवा का उद्देश्य अन्य सेवाओं से चयन प्राप्त करना और इसके आधार पर उपयोगकर्ता की प्रतिक्रिया तैयार करना है।

हम कॉन्फ़िगरेशन के साथ समीक्षा शुरू करते हैं।

SpringSecurityWebFluxConfig.java कॉन्फ़िगरेशन

 @Configuration @EnableReactiveMethodSecurity public class SpringSecurityWebFluxConfig { private static final String AUTH_TOKEN_PATH = "/auth/token"; @Value("${whiteListedAuthUrls}") private String[] whiteListedAuthUrls; @Value("${jwtTokenMatchUrls}") private String[] jwtTokenMatchUrls; @Bean @Primary public SecurityWebFilterChain systemSecurityFilterChain( ServerHttpSecurity http, JwtService jwtService, @Qualifier("userDetailsRepository") ReactiveUserDetailsService userDetailsService ) { 

यहां हम userDetailsService सेवाओं से एक प्रमाणीकरण प्रबंधक userDetailsService हैं, जिसे हमने पहले userDetailsService auth-module में परिभाषित किया था।

  UserDetailsRepositoryReactiveAuthenticationManager authenticationManager = new UserDetailsRepositoryReactiveAuthenticationManager(userDetailsService); 

और हम इस प्रबंधक के साथ एक फ़िल्टर बनाते हैं, और उपयोगकर्ता-डेटा को x-www-form-urlencoded में एन्कोड करने के लिए एक प्रमाणीकरण उदाहरण कनवर्टर भी जोड़ते हैं।

  AuthenticationWebFilter tokenWebFilter = new AuthenticationWebFilter(authenticationManager); tokenWebFilter.setServerAuthenticationConverter(exchange -> Mono.justOrEmpty(exchange) .filter(ex -> AUTH_TOKEN_PATH.equalsIgnoreCase(ex.getRequest().getPath().value())) .flatMap(ServerWebExchange::getFormData) .filter(formData -> !formData.isEmpty()) .map((formData) -> { String email = formData.getFirst("email"); String password = formData.getFirst("password"); return new UsernamePasswordAuthenticationToken(email, password); }) ); 

हम एक सफल प्राधिकरण हैंडलर जोड़ते हैं, जिसका सार Authentication से उत्पन्न अनुरोध हेडर में JWT टोकन डालना है ताकि प्रमाणीकरण केवल एक मान्य अतिथि टोकन का उपयोग करके बनाया जा सके।

  tokenWebFilter.setAuthenticationSuccessHandler(new JwtAuthSuccessHandler(jwtService)); MicroserviceServiceJwtAuthWebFilter webApiJwtServiceWebFilter = new MicroserviceServiceJwtAuthWebFilter(jwtService, jwtTokenMatchUrls); http.csrf().disable(); http .authorizeExchange() 

हम श्वेत सूची से पते हल करते हैं। जैसा कि मैंने पहले लिखा था, JWT फ़िल्टर द्वारा संसाधित किए जाने वाले पते भी खोले जाने चाहिए

  .pathMatchers(whiteListedAuthUrls) .permitAll() .and() .authorizeExchange() 

हम मूल प्रमाणीकरण के साथ एक्ट्यूएटर और कुछ पते की रक्षा करते हैं

  .pathMatchers("/actuator/**").hasRole("SYSTEM") .pathMatchers(HttpMethod.GET, "/url-protected/**").hasRole("GUEST") .pathMatchers(HttpMethod.POST, "/url-protected/**").hasRole("USER") .and() .httpBasic() .and() .authorizeExchange() 

प्रमाणीकरण टोकन पहुंच अनिवार्य करना

  .pathMatchers(AUTH_TOKEN_PATH).authenticated() .and() 

फ़िल्टर जोड़ें। JWT टोकन को प्रमाणित और सत्यापित करने के लिए।

  .addFilterAt(webApiJwtServiceWebFilter, SecurityWebFiltersOrder.AUTHENTICATION) .addFilterAt(tokenWebFilter, SecurityWebFiltersOrder.AUTHENTICATION); return http.build(); } 

और जैसा कि मैंने ऊपर लिखा है, यह सेवा JWT टोकन चेक, अन्य सेवाओं के लिए सामान्य, application.properites में micoservice=false चर को निर्दिष्ट करके निष्क्रिय कर देती है।

टोकन जारी करना, पंजीकरण और प्राधिकरण नियंत्रक AuthController.java

मैं इस नियंत्रक का वर्णन नहीं करूंगा, क्योंकि यह विशुद्ध रूप से विशिष्ट है।

WebApiService.java सेवा

इस सेवा को WebApiMethodProtectedController.jav एक नियंत्रक कहा जाता है और एक दिलचस्प टिप्पणी है:

 @PreAuthorize("hasRole('GUEST')") public Flux<User> getAllUsers() { } 

यह एनोटेशन केवल अतिथि भूमिका वाले अधिकृत उपयोगकर्ताओं के लिए तरीकों तक पहुंच की अनुमति देता है।

परीक्षा कैसे दें

एक वातावरण बनाएँ:

टोकन प्राप्त करें

प्राप्त टोकन के साथ पर्यावरण में TOKEN चर को अपडेट करें।

एक नया उपयोगकर्ता पंजीकृत करें

पंजीकरण के बाद, आपको एक उपयोगकर्ता टोकन प्राप्त होगा। यह 10 घंटे में समाप्त हो जाता है। जब यह समाप्त हो जाता है तो आपको एक नया प्राप्त करने की आवश्यकता होती है। ऐसा करने के लिए, अतिथि टोकन को फिर से अनुरोध करें, पर्यावरण को अपडेट करें और अनुरोध को निष्पादित करें

इसके बाद, आप उपयोगकर्ताओं की सूची, गेम प्राप्त कर सकते हैं या एक नया गेम बना सकते हैं। और हिस्ट्रिक्स का परीक्षण भी करते हैं, git रिपॉजिटरी के लिए सेवा कॉन्फ़िगरेशन और एन्क्रिप्ट वैरिएबल देखें।

संदर्भ

• गिटहब भंडार
• कॉन्फ़िगरेशन रिपॉजिटरी
• वसंत माइक्रोसर्विस एक्शन में
• प्रतिक्रियात्मक अनुप्रयोगों के लिए हैंड्स-ऑन स्प्रिंग 5 सुरक्षा
• एक्शन में पुस्तक स्प्रिंग माइक्रोसिस्टम्स के लिए कोड
• प्रतिक्रियात्मक अनुप्रयोगों के लिए पुस्तक हैंड्स-ऑन स्प्रिंग 5 सिक्योरिटी के लिए कोड