Craig Walls

Cloud Native Spring: Discovery and Configuration

Wednesday, 9:00 AM EST

In this sessions we'll see how to use components of Spring Cloud to configure and discover microservices in a cloud native microservice-architected application. Specifically, we'll look at Spring Cloud Netflix and Netflix' Eureka and Ribbon projects for service discovery as well as the Spring Cloud Config project's configuration server to provide a central point of external configuration.

Microservice-architecture presents many benefits, not the least of which include opportunities to develop, evolve, scale, test, and deploy individual modules of an application independently from the rest of the application. But once an application is broken apart, a new set of challenges arises.

If the individual microservices are to work together in service of the greater application, then they must know about each other. Rather than hardcode the specifics of each microservice within every other microservice, it's better to provide a registry with which a service can register and other services may use to lookup those service details.

Microservices, like any application, will also likely depend on application-level configuration. It's generally a good idea to keep that configuration separate from the application itself, and this is even more true with microservices. Using a centralized configuration service, microservices can obtain their configuration details, some of which may be shared across many microservices. Because it is separate from the application/microservice code, that configuration itself can be versioned and evolve at a pace independent of the microservices it serves.

Cloud Native Spring: Tracing and Health

Wednesday, 11:00 AM EST

In this session, we'll look at how to monitor the health of individual services in a microservice-architected application as well as trace the path of data and processing as it flows from service to service. Specifically, we'll look at Spring Cloud Netflix and Netflix OSS' Hystrix project to not only apply the circuit breaker pattern for failure and latency protection to microservices and monitor the health of those circuit breakers in a running application. Additionally, we'll look at Spring Cloud Sleuth and Zipkin to trace processing through a microservice-based application.

Microservice-architecture presents many benefits, not the least of which include opportunities to develop, evolve, scale, test, and deploy individual modules of an application independently from the rest of the application. But once an application is broken apart, a new set of challenges arises.

Failure is always a possibility in any application. But when an application is composed of microservices, it's important for that each service contain its failure and keep its problems to itself to avoid cascading errors to other services. Likewise, latency can be a concern that is compounded when felt across multiple microservices and it's important to avoid cascading latency issues. By applying the circuit breaker pattern in your microservices, you can ensure that if anything goes wrong in a given service, it stays in that service and doesn't have any negative impacts to other services. Moreover, metrics published by those circuit breakers can provide helpful insight into the health of an application.

When things do go wrong, it may also be helpful to trace the flow and processing of information as it passes from one microservice to another. Traditionally, tracing involves following the logs of a single application. But in a microservice-based application where many services and many instances of those services are involved, tracing is much more challenging. What's needed is a way for microservices to submit timing and tracing information to a central tracing service that coordinates that data and can present the flow of data in a single, easily digested view.

Cloud Native Spring: Streams and Tasks

Wednesday, 1:30 PM EST

In this session, we'll see how to develop microservices that are components of a flow of data, but that do not necessarily involve REST. We'll also see how to develop ephemeral microservices–microservice that are triggered to perform a job, then shutdown when that job is complete. Specifically, we'll look at Spring Cloud Stream for flow-based microservices, Spring Cloud Task for ephemeral microservices, and Spring Cloud Data Flow which orchestrates those stream- and task-based services.

Microservice-architecture presents many benefits, not the least of which include opportunities to develop, evolve, scale, test, and deploy individual modules of an application independently from the rest of the application. But once an application is broken apart, a new set of challenges arises.

Microservices are commonly thought of as small REST-based services that are assembled to form a larger, more complete application. In reality, however, REST is only the communication mechanism which is only a implementation detail and not intrinsic to the notion of microservices. Meanwhile, data processing and integration between various components of an application and external services is a key factor of many applications. In cloud native applications, this kind of data flow and processing is still relevant.

Essential Spring Security

Wednesday, 3:15 PM EST

In this session, you'll learn how to take advantage of the latest features of Spring Security and Spring Boot to secure an application, both at the web layer and at the method-level.

Information is probably the most valuable item we now have; crooks are looking for ways to steal our data and identities by sneaking into unsecured applications. As software developers, we must take steps to protect the information that resides in our applications. Whether it’s an email account protected with a username/password pair or a brokerage account protected with a trading PIN, security is a crucial aspect of most applications.

Spring Security is an extension to the Spring Framework that provides security to Spring applications both at the HTTP request level as well as at method invocation.

Cloud Native Spring: User Interfaces and Security

Wednesday, 5:00 PM EST

In this session we'll consider how to put a face on the services in the cloud that comprise an application and how to ensure that communication between the user interfaces and the backend services is secure. Specifically, we'll look at Spring Cloud Netflix and the Zuul project to create an API gateway through which the UI can communicate with the services. And we'll see how to use Spring Security and Spring Security OAuth (along with Spring Boot autoconfiguration) to secure that communication.

Microservice-architecture presents many benefits, not the least of which include opportunities to develop, evolve, scale, test, and deploy individual modules of an application independently from the rest of the application. But once an application is broken apart, a new set of challenges arises.

Cloud Native Spring: Testing and Documentation

Thursday, 9:00 AM EST

In this session, we'll see how to define contracts for microservice APIs using Spring Cloud Contract that can assist in testing clients of those services. Additionally, we'll look at Spring RestDocs, a project that provides semi-automatic production of API documentation.

Microservice-architecture presents many benefits, not the least of which include opportunities to develop, evolve, scale, test, and deploy individual modules of an application independently from the rest of the application. But once an application is broken apart, a new set of challenges arises.

Testing microservices, particularly when testing the code in one service that invokes another, can be challenging. It involves writing tests that mock out the remote service. But since it they target a remote service whose code is separate, those mocks may fall out of sync with changes in the service that they mock. Rather than manually write mocks against our own understanding of an API, it would be better to define a contract that both the remote API and the mock agree upon. And for testing purposes, mocks can be generated from that contract.

When it comes to documenting microservice APIs, you have a few choices: You can either fully automate documentation, based on the implementation code, or you can manually document the API. The former creates a tight-coupling between the documentation and the code, which makes the documentation fragile when the code changes. The latter requires much more effort, both in the initial creation as well as in keeping it in sync with API changes. But what if there were a middle-ground, a semi-automatic way to document an API?

Reactive Spring

Thursday, 10:45 AM EST

In this session, we'll explore the new reactive features in Spring 5 to build reactive, non-blocking applications using Spring's familiar programming model.

Traditionally, applications have been built using a blocking, synchronous model. Although comfortable and intuitive for most programmers, this model doesn't scale well. And although there are several new approaches to reactive programming, they don't necessarily fit into the familiar programming model that Spring developers are accustomed to working with.

Spring 5 has introduced a set of new reactive features, enabling non-blocking, asynchronous code that scales well using minimal threads. Moreover, it builds on the same concepts and programming models that Spring developers have used for years.

Extreme Spring APIs

Thursday, 1:30 PM EST

In this session, you'll learn how to design and develop REST APIs using Spring MVC, leveraging hypermedia to make those APIs easier for clients to consume and OAuth to make them more secure.

TBD

Serverless Spring: Spring Function as a Service

Thursday, 3:15 PM EST

Serverless is a big topic these days. More specifically, Function as a Service (FaaS) enables small-scale functions deployed in the cloud to be enabled only as needed. Compared to Platform as a Service (PaaS) services which are “always on” and require explicit scaling, FaaS services wake up when needed and are scaled by the platform automatically.

Imagine a service that only gets invoked one per hour. In PaaS, that service is always running and ready to handle requests, consuming processor resources and ultimately costing more to be ready at a moment's notice. In contrast, FaaS services awaken quickly upon invocation and go away when finished, conserving resources and cost.

In this example-driven session, we'll see how to create and deploy Function as a Service (FaaS) services with Spring and Spring Boot.