Emily Jiang, Java Champion discusses cloud-native microservices

Emily Jiang, Java Champion
Senior Technical Staff Member, IBM
Liberty Microservice Architect, Advocate
Senior Lead for MicroProfile and CDI
@emilyfhjiang
Creating a cloud-native microservice
– which programming mode should I use?

Characteristics
Specs, APIs, TCKs
Community Driven
Lightweight, Iterative
Processes
No Reference
Impls!

MicroProfile 1.0 (Fall 2016)
jaxrs-2.0
cdi-1.2
jsonp-1.0
MicroProfile 1.1 (August
2017)
microProfile-1.0
mpConfig-1.0
MicroProfile 1.2 (Sept 2017)
microProfile-1.1
mpConfig-1.1
mpFaultTolerance-1.0
mpHealth-1.0
mpMetrics-1.0
mpJwt-1.0
2017
2018
MicroProfile 1.3 (Dec 2017)
MicroProfile 1.2
mpConfig-1.2
mpMetrics-1.1
mpOpenApi-1.0
mpOpenTracing-1.0
mpRestClient-1.0
MicroProfile 1.4 (June 2018)
MicroProfile 1.3
mpConfig-1.3
mpFaultTolerance-1.1
mpJwt-1.1
mpOpenTracing-1.1
mpRestClient-1.1
2019
MicroProfile 2.0.1 (July
2018)
MicroProfile 1.4
jaxrs-2.1 // Java EE 8
cdi-2.0 // Java EE 8
jsonp-1.1 // Java EE 8
jsonb-1.0 // Java EE 8
MicroProfile 2.1 (Oct 2018)
MicroProfile 2.0
mpOpenTracing-1.2
MicroProfile 2.2 (Feb 2019)
Fault Tolerance 2.0
OpenAPI 1.1
OpenTracing 1.3
Rest Client 1.2
Jan
19.0.0.8
19.0.0.7 19.0.0.9
MicroProfile 3.0 (June
2019)
Metrics 2.0
Health Check 2.0
Rest Client 1.3

CDI 2.0
Latest release
JAX-RS 2.1 JSON-P 1.1
MicroProfile 3.0
JSON-B 1.0
Fault
Tolerance
2.0
Metrics 2.0
JWT
Propagation
1.1
Health
Check 2.0
Open
Tracing 1.3
Open API
1.1
Rest Client
1.3
Config 1.3
20+
Component
Releases!
9 Platform
Releases!
MicroProfile
3.0
Reactive
Streams
Operators
Reactive
Messaging
Context
Propagation
Standalone releases

Open specifications
Wide vendor support
REST services
OpenAPI support
Security
Fault Tolerance
Configuration
Metrics
Health
Open Tracing
https://wiki.eclipse.org/MicroProfile/Implementation
Implementations

Spring MicroProfile
Getting started
Starter https://start.spring.io/ https://start.microprofile.io/
REST
REST Service Spring MVC JAX-RS
Dependency Injection Spring IoC & DI CDI
API Documentation Spring REST Docs MP Open API
REST Client Spring MVC
Feign
MP REST Client
JSON Binding/Processing Bring Your Own Llibrary
Jackson, JSON-B
JSON-B
JSON-P
Reactive
Reactive Spring Reactor
Use Kafka APIs to connect
with Kafka
MicroProfile Reactive Streams
Operator, RxJava
MicroProfile Reactive
Messaging
Handling 100s of Services
Configuration Spring Boot Config
Spring Cloud Config
MP Config
Fault Tolerance Netflix Hystrix MP Fault Tolerance
Security Spring Security
Spring Cloud Security
EE Security
MP JWT Propagation
Operation Focus
Health Checks Spring Boot Actuator MP Health Check
Metrics Spring Boot Actuator MP Metrics
Distributed Tracing Spring Cloud Sleuth MP Open Tracing
Capabilities

https://start.microprofile.io
Getting started
https://start.spring.io/

There’s a good chance you’ll use REST APIs

REST Services
@ApplicationPath("/rest")
public class CatalogApplication
extends Application {
}
@Path("/items")
@Produces(MediaType.APPLICATION_J
SON)
public class CatalogService {..}
@GET
public List<Item> getInventory()
{…}
@GET
@Path("{id}")
public Response
getById(@PathParam("id") long id)
{…}
@SpringBootApplication
public class Application {
public static void main(String[] args)
{
SpringApplication.run(Application.class,
args);}
}
@RestController
public class CatalogController {..}
@RequestMapping(value = "/items", method
= RequestMethod.GET)
@ResponseBody
List<Item> getInventory() {..}
@RequestMapping(value = "/items/{id}",
method = RequestMethod.GET)
ResponseEntity<?> getById(@PathVariable
long id) {…}
Spring MicroProfile

JAX-RS in MicroProfile
B
@ApplicationPath("System")
public class SystemApplication extends
Application {}
@Path("properties")
public class PropertiesResource {
@GET
@Produces(MediaType.APPLICATION_JSON)
public JsonObject getProperties() {…}
}

Dependency Injection
@ApplicationPath("/rest")
public class JaxrsApplication extends
Application {
@Inject
private InventoryRefreshTask
refreshTask;
@ApplicationScoped
public class InventoryRefreshTask {
…
}
@Autowired
private InventoryRefreshTask
refreshTask;
Spring MicroProfile B

CDI for MicroProfile
A
public class InventoryManager {
@Inject
private SystemClient systemClient;
…
}

© 2018 IBM Corporation
Document APIs in Spring
1
8
1. Define the dependencies
<dependency>
<groupId>org.springframework.restdocs</groupId>
<artifactId>spring-restdocs-mockmvc</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.restdocs</groupId>
<artifactId>spring-restdocs-core</artifactId>
<scope>test</scope> </dependency>
2. Define your Rest service
--------------------
@RestController
public class CatalogController {
@RequestMapping("/")
public @ResponseBody String index() {
return "Greetings from Catalog Service !";
}
}
-----------------
3. Define all necessary test classes
@RunWith(SpringRunner.class)
@SpringBootTest(classes = CatalogController.class)
@WebAppConfiguration
public class CatalogControllerTest {
@Rule public JUnitRestDocumentation restDocumentation = new JUnitRestDocumentation("target/generated-snippets");
private MockMvc mockMvc;
@Autowired private WebApplicationContext context;
@Before public void setUp() {
mockMvc = MockMvcBuilders.webAppContextSetup(context) .apply(documentationConfiguration(restDocumentation)) .build();
}
4. Use alwaysDo(), responseFileds(), requestPayload(), links(),
fieldWithPath(), requestParameters(), pathParameters() to
document
@Test
public void crudDeleteExample() throws Exception {
this.mockMvc.perform(delete("/crud/{id}", 10)).andExpect(status().isOk())
.andDo(document("crud-delete-example",
pathParameters(
parameterWithName("id").description("The id of the input to delete")
)));
}

MicroProfile OpenAPI
A B
openapi: 3.0.0
info:
title: Inventory App
description: App for storing JVM system properties of various
hosts.
license:
name: Eclipse Public License - v 1.0
url: https://www.eclipse.org/legal/epl-v10.html
version: "1.0"
servers: - url: http://localhost:{port} description: Simple Open
Liberty.
variables:
port:
description: Server HTTP port.
default: "9080"
paths:
/inventory/systems:
get:
summary: List inventory contents.
description: Returns the currently stored host:properties pairs
in the inventory.
operationId: listContents
responses:
200:
description: host:properties pairs stored in the inventory.
content:
application/json:
schema:
$ref: '#/components/schemas/InventoryList’
….
http://localhost:9080/openapi/ui
@GET
@APIResponse(
responseCode = "200",
description = "host:properties pairs stored in the inventory.",
content = @Content( mediaType = "application/json",
schema = @Schema( type = SchemaType.OBJECT,
implementation = InventoryList.class)))
@Operation( summary = "List inventory contents.",
description = "Returns the stored host:properties pairs.")
public InventoryList listContents() { return manager.list(); }

REST Clients
2
1
@Dependent
@RegisterRestClient
@RegisterProvider(InventoryResponseExceptionMapper.class)
// Optional
public interface InventoryServiceClient {
@GET
List<Item> getAllItems() throws UnknownUrlException,
ServiceNotReadyException;
}
@Inject
@RestClient
private InventoryServiceClient invClient;
final List<Item> allItems = invClient.getAllItems();
@FeignClient(name="inventory-service",
url="${inventoryService.url}")
public interface InventoryServiceClient {
@RequestMapping(method=RequestMethod.GET,
value="/micro/inventory",
produces={MediaType.APPLICATION_JSON_VALUE})
List<Item> getAllItems();
}
@EnableFeignClients
@Autowired
private InventoryServiceClient invClient;
final List<Item> allItems = invClient.getAllItems();
Spring MicroProfile

MicroProfile REST Client
BA
@Inject
@RestClient
private SystemClient
defaultRestClient;
@Dependent
@RegisterRestClient
@RegisterProvider(UnknownUrlExceptionMapper.class)
@Path("/properties")
public interface SystemClient {
@GET
public Properties getProperties() throws
UnknownUrlException, ProcessingException;
}
io.openliberty.guides.inventory.client.SystemClient/mp-rest/url=http://localhost:9080/system

JSON Binding/Processing
import javax.json.bind.Jsonb;
import javax.json.bind.JsonbBuilder;
Jsonb jsonb = JsonbBuilder.create();
String result = jsonb.toJson(artists);
import
com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
final ObjectMapper objMapper = new ObjectMapper();
jsonString = objMapper.writeValueAsString(item);
// or
import javax.json.bind.Jsonb;
import javax.json.bind.JsonbBuilder;
Jsonb jsonb = JsonbBuilder.create();
String result = jsonb.toJson(artists);
MicroProfile
Spring

JSON-B & JSON-P in MicroProfile
A B
...
@GET
public InventoryList listContents() {
return manager.list();
}
public class InventoryList {
private List<SystemData> systems;
public InventoryList(List<SystemData> systems) {
this.systems = systems;
}
public List<SystemData> getSystems() {
return systems;
}
public int getTotal() {
return systems.size();
}
}

Reactive
MicroProfile Reactive Stream Operators
to work with Reactive Streams
Can also use RxJava
MicroProfile Reactive Messaging
Spring
MicroProfile
Use Spring Reactor
Directly use Kafka APIs or Spring boot
annotations to interact with Kafka
streams
@KafkaListener(topics = "users", groupId = "group_id")
public void consume(String message){
…
}
@Autowired
private KafkaTemplate<String,String> kafkaTemplate;
public void sendMessage(String message){
logger.info(String.format("$$ -> Producing message
--> %s",message));
this.kafkaTemplate.send(TOPIC,message);
}

Configuration
2
9
# Elasticsearch
elasticsearch_url=http://es-catalog-
elasticsearch:9200
elasticsearch_index=micro
elasticsearch_doc_type=items
=====================
Config config = ConfigProvider.getConfig();
private String url =
config.getValue("elasticsearch_url",
String.class);
=====================
@Inject
@ConfigProperty(name=“elasticsearch_url”)
String url;
# Elasticsearch
elasticsearch:
url: http://localhost:9200
user:
password:
index: micro
doc_type: items
=====================
@Component("ElasticConfig")
@ConfigurationProperties(prefix = "elasticsearch")
public class ElasticsearchConfig {
// Elasticsearch stuff
private String url;
private String user;
…
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
}
@Autowired
private ElasticsearchConfig config;
url = config.getUrl();
Spring MicroProfile

Fault Tolerance
import org.eclipse.microprofile.faulttolerance.Fallback;
import org.eclipse.microprofile.faulttolerance.Retry;
import org.eclipse.microprofile.faulttolerance.Timeout;
@Timeout(value = 2, unit = ChronoUnit.SECONDS)
@Retry(maxRetries = 2, maxDuration = 2000)
@CircuitBreaker
@Fallback(fallbackMethod = "fallbackInventory")
@Asynchronous
@GET
public CompletionStage<Item> getInventory() {
….
}
public CompletionStage<Item> fallbackInventory() {
//Returns a default fallback
return fallbackItem;
}
@Service
public class AppService {
@HystrixCommand(fallbackMethod = "fallback")
public List<Item> getInventory() {
return items;
}
public List<Item> fallback() {
//Returns a default fallback
return fallbackitemslist;
}
}
import
org.springframework.cloud.client.circuitbreaker.En
ableCircuitBreaker
@RestController
@EnableCircuitBreaker
...
}
Spring MicroProfile

MicroProfile Fault Tolerance
A B
@Fallback(fallbackMethod = "fallbackForGet")
public Properties get(String hostname) throws
IOException {
return invUtils.getProperties(hostname);
}

© 2018 IBM Corporation
Security: Consuming Json Web Tokens
@DeclareRoles({"Admin", "User"})
@RequestScoped@Path("/orders")
public class OrderService {
@Inject private JsonWebToken jwt;
public Response getOrders() throws Exception {
final String customerId = jwt.getName();
if (customerId == null) {
return “BAD_REQUEST”
}
OrderDAOImpl ordersRepo = new OrderDAOImpl();
final List<Order> orders =
ordersRepo.findByCustomerIdOrderByDateDesc(customerId);
return Response.ok(orders).build();
}
@Configuration
@EnableWebSecurity
@EnableREsourceServer
public class OAuth2ResourceServerConfig extends
ResourceServerConfigurerAdapter {
@Autowired
Private JWTConfig securityConfig;
……….
……….
}
Spring
MicroProfile

MicroProfile JWT
A B
@GET
@RolesAllowed({ "admin", "user" })
@Path("{hostname}")
public Response getPropertiesForHost(@PathParam("hostname") String hostname,
@Context HttpHeaders httpHeaders) {…}

Handling 100s of collaborating services
requires a strong operations focus

Health Checks
MP Health
Custom health implementation
/health/ready
@Readiness
public class HealthEndpoint
implements ReadinessHealthCheck {
@Override
public HealthCheckResponse
call() {…}
}
/health/live
@Liveness
public class LivenessHealthEndpoint
implements HealthCheck {
@Override
public HealthCheckResponse
call() {…}
}
SpringBoot Actuator
/health – provides us basic health info.
Custom health implementation
@Component
public class HealthCheck implements
HealthIndicator {
@Override
public Health health() {
int errorCode = check(); //
perform some specific health check
if (errorCode != 0) {
return Health.down()
.withDetail("Error
Code", errorCode).build();
}
return Health.up().build();
}
public int check() {
// Our logic to check health
return 0;
}
}
Spring MicroProfile

Metrics
MP Metrics - /metrics endpoint
import
org.eclipse.microprofile.metrics.annotation.Counte
d;
import
org.eclipse.microprofile.metrics.annotation.Metere
d;
import
org.eclipse.microprofile.metrics.annotation.Timed;
@Timed(name = "Inventory.timer", absolute = true,
displayName="Inventory Timer", description =
"Time taken by the Inventory", reusable=true)
@Counted(name="Inventory", displayName="Inventory
Call count", description="Number of times the
Inventory call happened.", monotonic=true,
reusable=true)
@Metered(name="InventoryMeter",
displayName="Inventory Call Frequency",
description="Rate of the calls made to Inventory",
reusable=true)
// Get all rows from database
public List<Item> findAll(){ }
Spring Actuator - /metrics endpoint
Custom Metrics implementation
@Service
public class LoginServiceImpl {
private final CounterService
counterService;
public List<Item> findAll (CounterService
counterService) {
this.counterService = counterService;
if(list.size()>1)
counterService.increment("counter.list.valid
");
else
counterService.increment("counter.list.invalid
");
……………..
………………
……………….
}
Spring MicroProfile

Distributed Tracing
MP OpenTracing
Configuring this features allows us to generate traces for the application
Custom Trace Implementation
import org.eclipse.microprofile.opentracing.Traced;
import io.opentracing.ActiveSpan;
import io.opentracing.Tracer;
@Traced(value = true, operationName ="getCatalog.list")
public List<Item> getInventory() {
try (ActiveSpan childSpan = tracer.buildSpan("Grabbing
messages from Messaging System").startActive()) { }
}
Spring Cloud Sleuth
If the Spring cloud sleuth is configured on the class path, the trace information
will get generated automatically.
Spring
MicroProfile

Our Perspectives
• Developers should be free to choose
what they prefer
• Enterprise should provide developers
with platforms that enable innovation and
flexibility and are enterprise and
production ready
• Liberty supports both MicroProfile/EE
and Spring
• Fast, small, reliable runtime
• Optimized for containers and cloud
• True liberty for microservice developers
and administrators
• Spring is popular
• MicroProfile and Jakarta EE are evolving
rapidly (and gaining momentum) as
community-driven and standards-based
efforts for developing microservices and
cloud-native applications in enterprise
Java
• Both Spring and MicroProfile provide
facilities for developers to build next-
generation applications for cloud
• Share similarities
• There are differences too (and
sometimes, significant)
• Lightweight runtimes for Java/Jakarta EE
are readily available nowadays

Spring Impl MicroProfile Impl
APIs Open Source
Driven by Pivotal
Spring way of things
Open Source
Driven by Community
Open standards
Behaviors in accordance
specifications
Line
s of
Cod
e
More code
Do what you want/need with
code (and configuration)
Less code
Customize server configuration
Libr
arie
s/De
pen
den
cies
Find, mix and match what you
like
Manage your own dependencies
Runtime provides what is needed
per specifications
Appl
icati
on
Pac
kagi
ng
Fat JARs Thin WAR
Note: Liberty has optimized
support for Spring Boot apps in
containers

References
● https://www.ibm.com/blogs/bluemix/2018/09/migrate-java-microservices-from-spring-to-
microprofile-p1/
● https://microprofile.io
○ https://projects.eclipse.org/projects/technology.microprofile
○ https://microprofile.io/projects/
○ https://wiki.eclipse.org/MicroProfile/Implementation
● https://openliberty.io
○ https://openliberty.io/guides/
○ https://openliberty.io/downloads/
○ https://github.com/OpenLiberty/open-liberty

Emily Jiang, Java Champion discusses cloud-native microservices

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (19)

Similaire à Emily Jiang, Java Champion discusses cloud-native microservices

Similaire à Emily Jiang, Java Champion discusses cloud-native microservices (20)

Plus de Emily Jiang

Plus de Emily Jiang (12)

Dernier

Dernier (20)

Emily Jiang, Java Champion discusses cloud-native microservices