Spring Cloud: Why? How? What?

Speaker
• Orkhan Gasimov, Software Engineer
– 14 years of software engineering;
– variety of technologies (languages & frameworks);
– solution design and implementation;
• Teaching training courses.
– Architecture.
– Java.
– JavaScript / TypeScript.
• Author of training courses.
– Spring Cloud.
– Akka for Java.

Spring Cloud
• Why?
– Provide the Spring developer with an
easily consumable set of tools to build
distributed systems.
Motivation

Spring Cloud
• Why?
• How?
– Wrapping other implementation stacks,
that are then consumed via the familiar
tools.
Motivation
Process

Spring Cloud
• Why?
• How?
– Wrapping other implementation stacks,
that are then consumed via the familiar
tools.
• What?
– Set of tools for developers to quickly
build some of the common patterns in
Process
Motivation
Product

Spring Cloud
• Microservices
• Core Components
• Instrumentation
• Security
• Messaging & Streaming
• Distributed Event Bus
• Configuration Management
• Questions & Answers

Spring Cloud
• Spring Cloud Netflix
• Spring Cloud Sleuth
• Spring Cloud Security
• Spring Cloud Streams
• Spring Cloud Bus
• Spring Cloud Config

Examples
• A few notes about code examples:
– We will see
• Spring Cloud project names.
• Simplified Java code examples.
• Basic configuration options.
– We omit
• Dependencies – easy to find at official website.
• Extensive configuration options – available in official documentation.

Microservices
• Approach or Architecture?
– Approach
• Introduces general guidelines on ways of performing
the work.
– Architecture
• Defines the structured solution that meets all of the
technical and operational requirements.

Microservices
• Approach from organizational point of view.
– Which tools are going to be used?
– What technology stacks are available?
– How processes are going to be organized?
– Which protocols will be used?
– How the deployment will be organized?

Microservices
• Architecture from development point of view.
– Which elements will be used to build the software?
– How relations between elements will be organized?
– How elements will be structured?
– How elements, relations and structure are configured?

Core Components
• Spring Cloud
– built on top of Spring Boot.
– ready for microservice development.
• Multiple implementations of common patterns.
– E.g. support for Eureka, ZooKeeper and Consul.

Core Components
• Spring Cloud Netflix.
– Discovery server and client.
– Latency and fault tolerance library.
– Client-side load balancing over RestTemplate.
– Declarative REST client.
– Edge proxy for API gateway implementations.

Core Components – Service Discovery
• A simple discovery server implementation using Spring Cloud looks like:
– By default Eureka will be available at http://localhost:8761/eureka
– Custom settings should be configured in bootstrap.yml (or .properties)
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer
public class DiscoveryServer {
public static void main(String[] args) {
SpringApplication.run(DiscoveryServer.class, args);
}
}

• A simple discovery server configuration looks like:
spring:
application:
name: DiscoveryServer
server:
port: 8761
eureka:
server:
enable-self-preservation: false

• Eureka
– Self-Preservation
– Peer Awareness
– Availability Zones
– Regions

• Peer awareness configuration for two discovery server instances looks like:
spring:
application:
server:
port: 8761
eureka:
server:
client:
fetchRegistry: true
registerWithEureka: true
serviceUrl:
defaultZone: http://host2:8761/eureka
spring:
application:
server:
port: 8761
eureka:
server:
client:
fetchRegistry: true
serviceUrl:
defaultZone: http://host1:8761/eureka

• A simple service with discovery client looks like:
@EnableEurekaClient //@EnableDiscoveryClient
@RestController
public class HelloService {
@RequestMapping("/hello")
public String sayHello(@RequestParam String name) {
return "Hello " + name;
}
SpringApplication.run(HelloService.class, args);
}
}

• A simple service configuration looks like:
spring:
application:
name: HelloService
eureka:
client:
fetchRegistry: true
serviceUrl:
defaultZone: http://localhost:8761/eureka

Core Components – Load Balancing
• How do we load balance between instances of HelloService?

• Ribbon – the client-side load
balancer.
• Ribbon supports auto-retry, time-out
and other useful configurable
features.

• Spring Cloud implements Ribbon as a wrapper over RestTemplate.
• Default load balancing logic is round-robin.

@Bean
@LoadBalanced
public RestTemplate restTmpl() {
return new RestTemplate();
}
@RestController
public class HelloWorldRest {
@Autowired
private RestTemplate restTmpl;
@RequestMapping("/hello-world")
public String sayHello() {
String url = "http://HelloService/hello?name=World";
return restTmpl.getForObject(url, String.class);
}
}

Core Components – Circuit Breaker
• Remote service fails or is not available:

– Long-running requests that result in failure.

– Users wait to get the failure response.

• Failure continues for some unpredictable time:

– More dependent services can be blocked.

– More dependent services can be blocked.
– Longer response times, more users have to wait…

• Some of service dependencies will inevitably fail.

– Cascading failures turn into a chain reaction.

– Cascading failures turn into a chain reaction.
• Hystrix helps to control the interactions between distributed services by
adding latency tolerance and fault tolerance logic.

• Hystrix – the circuit breaker.
– Isolates points of access between services.
– Stops cascading failures.
– Provides fallback options.

@EnableHystrix //@EnableCircuitBreaker
@RestController
//other annotations – Eureka, etc.
public class HelloWorldService {
//beans, autowires, main method...
@HystrixCommand(fallbackMethod = "helloFallback")
@RequestMapping("/hello-world")
public String sayHello() {
String url = "http://HelloService/hello?name=World";
return restTmpl.getForObject(url, String.class);
}
private String helloFallback() {
return "Sorry World, try again later please.";
}
}

Core Components – REST Client
• Feign – declarative REST client.

– Integrated support for Eureka, Ribbon and Hystrix.

– Enabled by adding @EnableFeignClients to your configuration class.

– Enabled by adding @EnableFeignClients to your configuration class.
@FeignClient(name = "HelloService")
public interface HelloClient {
String sayHello(@RequestParam String name);
}

• Feign client with Hystrix fallbacks:
@FeignClient(name = "HelloService", fallback = HelloFallback.class)
public interface HelloClient {
String sayHello(@RequestParam String name);
}
@Component
public class HelloFallback implements HelloClient {
@Override
public String sayHello(String name) {
return "Sorry " + name + ", try again later please";
}
}

Core Components
• Let’s imagine we are building an
application with microservices
architecture.
• Services depend on other services.

Core Components
architecture.
• Services find each other through
service discovery.

Core Components
architecture.
• Services find each other through
service discovery.
• How do clients integrate with our
microservices?

Core Components – API Gateway
• API gateway is the single entry
point for clients.

point for clients.
• The API gateway handles requests
in one of two ways:

point for clients.
in one of two ways:
– Simply proxy/route requests to the
appropriate service.

point for clients.
in one of two ways:
– Simply proxy/route requests to the
appropriate service.
– Expose a different API for each
client.

• API gateway – the single entry point to your microservices
– eliminates the hassle of dealing with your internal infrastructure.
• Zuul – the edge proxy which is integrated with Eureka, Ribbon & Hystrix.

• Zuul configuration example:
zuul:
ignoredServices: '*'
routes:
hello:
path: /hello/**
serviceId: HelloService
stripPrefix: true
hello-world:
path: /world/**
serviceId: HelloWorldService
stripPrefix: true
@EnableZuulProxy
public class ApiProxy {
//main method...
}

Core Components
– Eureka
• service discovery server and client.
– Ribbon
• client-side load balancer.
– Hystrix
• circuit breaker.
– Feign
• declarative REST client.
– Zuul
• edge-proxy for API gateway implementations.

Instrumentation
• Hystrix – near real-time metrics.
– Metrics stream is available at /hystrix.stream.
– Can be visualized with Hystrix Dashboard.

Instrumentation
• Hystrix Dashboard
@EnableHystrixDashboard
public class Dashboard {
//main method...
}

Instrumentation
• Hystrix metrics stream contain:
– Health indicator;
– Traffic volume;
– Request rate;
– Host count;
– Error percentage;
– Circuit-breaker status;
– Latency stats;
– Success count
– Reject count;
– Timeouts;
– Failures/Exception;
– Etc.

Instrumentation
• Turbine – aggregates metrics from Hystrix instrumented cluster.

Instrumentation
• Turbine AMQP allows any application post metrics to the single stream.
– Turbine Server – aggregates all metrics sent to the stream.

Instrumentation
• Spring Cloud Sleuth – distributed tracing compatible with Dapper, Zipkin
and HTrace.

Instrumentation
• Integrated tools for metrics and tracing
– Hystrix Stream and Hystrix Dashboard
• near real-time monitoring of circuit breakers at a single host.
– Turbine
• the Hystrix Stream aggregator that allows to monitor all nodes in cluster.
– Turbine AMQP
• the Hystrix Stream aggregator that allows to monitor all applications in network.
– Sleuth & Zipkin
• distributed tracing of cascading calls between microservices.

Security
• Implementations:
– API Gateway / Perimeter Security;
– Everybody Can Auth (with HTTP Basic);
– Basic + Central Auth DB;
– Sessions Everywhere;
– API Tokens;
– SAML;
– Etc.

Security
• Common concerns:
– Central user store bottleneck;
– Lack of single sign on;
– Statelessness;
– Exposure of user credentials;
– Lack of fine grained authorization;
– Interoperability with non browser clients;

Security

Security
– OAuth2 – delegated authorization.

Security
– JWT (JSON WebToken) – self-contained tokens.

Security
– OpenID Connect – delegated authentication.

Security
– OpenID Connect – delegated authentication.
– SSO through API gateway using Zuul.

Security
User Authentication and Authorization server (UAA) sample
configuration

Security – UAA sample configuration
@Configuration
@EnableAuthorizationServer
public class OAuth2Configuration extends AuthorizationServerConfigurerAdapter {
@Autowired
@Qualifier("authenticationManagerBean")
private AuthenticationManager authenticationManager;
@Bean
public TokenStore tokenStore() {
return new JwtTokenStore(jwtTokenEnhancer());
}
@Bean
protected JwtAccessTokenConverter jwtTokenEnhancer() {
KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(
new ClassPathResource("jwt.jks"), "mySecretKey".toCharArray()
);
JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
converter.setKeyPair(keyStoreKeyFactory.getKeyPair("jwt"));
return converter;
}

@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
clients.inMemory()
.withClient("client")
.secret("secret")
.scopes("openid")
.autoApprove(true)
.authorizedGrantTypes("implicit","refresh_token", "password", "authorization_code");
}
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
endpoints.tokenStore(tokenStore()).tokenEnhancer(jwtTokenEnhancer())
.authenticationManager(authenticationManager);
}
@Override
public void configure(AuthorizationServerSecurityConfigurer oauthServer) throws Exception {
oauthServer.tokenKeyAccess("permitAll()").checkTokenAccess("permitAll()");
}
}

@Configuration
class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
@Bean
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.csrf().disable()
.authorizeRequests()
.antMatchers("/**").authenticated()
.and().httpBasic()
.and().formLogin().permitAll()
.and().logout();
}

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication()
.withUser("account")
.password("account")
.authorities("ACCOUNT_READ", "ACCOUNT_WRITE", "ACCOUNT_PROCESS")
.and()
.withUser("card")
.password("card")
.authorities("CARD_WRITE", "ACCOUNT_READ")
.and()
.withUser("client")
.password("client")
.authorities("CLIENT_READ", "CLIENT_WRITE", "ACCOUNT_READ", "CARD_READ")
.and()
.withUser("processing")
.password("processing")
.authorities("PROCESSING", "ACCOUNT_PROCESS");
}
}

Security
Resource Server configuration

Security – Resource Server configuration
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
@Bean
@LoadBalanced
public OAuth2RestTemplate oAuth2RestTemplate(OAuth2ProtectedResourceDetails details) {
return new OAuth2RestTemplate(details);
}
@Override
public void configure(HttpSecurity http) throws Exception {
http
.csrf().disable()
.authorizeRequests()
.antMatchers("/**").authenticated()
.antMatchers(HttpMethod.GET, "/test").hasAuthority("PROCESSING");
}
}

Security – Resource Server configuration
security:
oauth2:
client:
clientId: client
clientSecret: secret
scope: openid
accessTokenUri: http://localhost:8500/uaa/oauth/token
userAuthorizationUri: http://localhost:8500/uaa/oauth/authorize
resource:
jwt:
key-uri: http://localhost:8500/uaa/oauth/token_key

Security – SSO with Zuul
• To enable SSO at Zuul:
@EnableZuulProxy
@EnableOAuth2Sso
public class ApiGateway {
//main method...
}

Security
– OAuth2 for delegated authorization.
– JWT for self-contained tokens.
– OpenID Connect for delegated authentication.
– SSO with Zuul at API gateway.

Messaging & Streaming
• Spring Cloud Stream – messaging/streaming API.

• Features:
– Publish-Subscribe;
– Consumer Groups;
– Partitioning;

• Features:
– Publish-Subscribe;
– Consumer Groups;
– Partitioning;
• REST – synchronous microservices.
• Spring Cloud Stream – asynchronous microservices.

• Basic channel abstraction interfaces:
– Sink – output message channel.
– Source – input message channel.
– Processor – extends Sink and Source.

• A simple processor application with Spring Cloud Stream looks like:
@EnableBinding(Processor.class)
public class WordNumFilter {
@StreamListener(Processor.INPUT)
@SendTo(Processor.OUTPUT)
private String filter(String word) {
//filter numbers, return only words
}
//main method...
}

• Configuration for the channels looks like:
spring:
application.name: WordNumFilter
cloud.stream.bindings:
input:
destination: wordNumFilter
group: WordNumFilters
consumer:
partitioned: true
instanceCount: 2
instanceIndex: 0
output:
destination: words

Distributed Event Bus
• Spring Cloud Bus – distributed event bus.
– Built on top of Spring Cloud Stream.
– Integrates with application events.

Distributed Event Bus
• Event publisher and listener example:
public class MyEventPublisher {
@Autowired
private SpringCloudBusClient busClient;
public void publishEvent(MyEvent event) {
busClient.springCloudBusOutput().send(
MessageBuilder.withPayload(event).build()
);
}
}
@EventListener
public void handleEvent(MyEvent event) {
//or implement ApplicationListener<MyEvent>
}

Configuration Management
• Configuring applications separately is uncomfortable.

– Application are deployed to different hosts.

– Application are deployed to different hosts.
– Different environments (DEV, RC, PROD).

• Spring Cloud Config – server and client support for external configuration.

• Features:
– HTTP-based API for external configuration.

• Features:
– Encrypt and decrypt property values.

• Features:
– Encrypt and decrypt property values.
– Git as default repository storage.
• File-based, SVN and other options are available.

• Config Server is the central place to manage external properties for
applications across all environments.

Config Server application:
Config Server configuration: Config Client configuration:
@EnableConfigServer
public class ConfigServer {
SpringApplication.run(ConfigServer.class, args);
}
}
spring.cloud.config.server.git:
uri: http://git.xyz/config-repo
username: user
password: passkey
spring:
application.name: AppName
cloud.config.uri: http://host:8182

• Spring Cloud Config Monitor
– Configuration updates are delivered to applications without restart.

Questions & Answers
– Eureka, Ribbon, Hystrix, Feign, Zuul
– Hystrix Stream and Hystrix Dashboard
– Turbine & Turbine AMQP
• Spring Cloud Sleuth
– Zipkin
– OAuth2 + JWT, OpenID Connect + SSO
• Spring Cloud Streams
• Spring Cloud Bus
• Spring Cloud Config

Spring Cloud: Why? How? What?

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Spring Cloud: Why? How? What?

Similar to Spring Cloud: Why? How? What? (20)

More from Orkhan Gasimov

More from Orkhan Gasimov (15)

Recently uploaded

Recently uploaded (20)

Spring Cloud: Why? How? What?