Java Microservices with Spring Cloud: Coordinating Services

Course Overview
Hey there everyone, my name's Richard Seroter and welcome to my course about coordinating Java Microservices with Spring Cloud. I'm a Senior Director of product at Pivotal, the company behind the wildly popular Spring framework. Spring Boot and Spring Cloud are now the most widely used frameworks for building modern Java apps. With tens of millions of downloads per month for Maven, Spring Boot has exploded in popularity. And Spring Cloud is right behind it at an unstoppable trajectory. Why is that? These projects solve real challenges while also introducing developers to new patterns that result in better applications. In this course, we're going to go deep on the parts of Spring Cloud that make it easier to link together services in a microservices architecture. Some of the things we're going to cover include how to locate and consume microservices at run time, protecting microservices with circuit breakers, routing requests using load balancing and micro proxies, stitching services together via messaging middleware, and building data pipelines. By the end of this course, you'll know how to use five key Spring Cloud libraries and how to use them to deliver more resilient, scalable, and maintainable microservices. Before beginning this course, you'll want to be familiar with Java Programming and Spring Boot, but don't worry, there's help along the way if you're not an expert in either of those. I hope you'll join me on this journey to learn all about coordinating Java microservices with Spring Cloud in my course here at Pluralsight.

Introducing Spring Cloud and Microservices Coordination Scenarios
Hi there. My name's Richard Seroter, welcome to this course about coordinating Java microservices using Spring Cloud. I'm really excited about this course. This is an exciting technology. This is a great time to be using Java in Spring to build modern microservices, so I'm happy you've decided to take this journey with me. We're going to kick off this course with a module here about the challenges of coordinating microservices interactions, what Spring Cloud offers to help. In a previous course, I looked at how do you build these Java microservices with Spring Cloud using config servers, tasks, security and more. In this course, we're going to look at the Spring Cloud projects that make it easier for microservices to interact with each other. We're going to start off talking about why microservices architectures have become popular. We'll discuss some of the core characteristics of a microservice. I'll bring up some of the coordination challenges that come up and emerge with a microservices architecture. We'll discuss what microservices with Spring Cloud look like. I'll share some of the Spring Cloud projects we'll actually be using in this course so you know what to expect. We'll talk about some of the capabilities, things we're going to build, what is this project that we're going to work on throughout all of the modules in this course. We'll discuss some of the goals here that we have together. I'll bring up a few of the prerequisites to be ready for and then we'll wrap up.

Locating Services at Runtime Using Service Discovery
Hey, my name's Richard Seroter. Welcome to this module in course about coordinating Java microservices. In this module, we're going to talk about service registration and discovery. This a crucial part of a microservices architecture. I think you're going to have fun with this. We're going to start this by talking about the role of service discovery in microservices, some of the problems with the status quo, and this will be a template we follow with each of the modules, kind of setting up the situation. Then we'll describe, what is Spring Cloud Eureka? What function does it perform? How do you create a Eureka Server? This is a really simple process, but we want to walk through that, get a sense for what it means to create one and configure one. We'll register some services with Eureka. We'll see how you can discovers services in your client code. We'll configure some health information, actually mess around with purposefully triggering some failures to see what happens. We'll talk about some of the high availability considerations when using Eureka. Then we'll discuss some options for advanced configuration before wrapping up. As we set up in the first module and talked about the use case that we're going to be working on throughout this course, in this particular one, we're going to cover the service discovery and some of the client side load balancing, at least introducing the concept. So what we'll end up doing is building the service discovery piece, messing with some load balancing, calling a handful of services seeing them register with our service discovery and service registration service.

Protecting Systems with Circuit Breakers
Hey there, my name is Richard Seroter, welcome to this module in a course about coordinating Java micro services. In this particular module, we're going to talk about the topic of resilience and see how to protect your ecosystem, your set of services from falling down just because a single service experiences a disruption. Specifically, we'll talk about the role of circuit breakers in your micro services architecture. Some of the problems with the status quo when dealing with resilience, we'll talk about Spring Cloud Hystrix and what that offers and brings to the table. We'll actually create a Hystrix Protected Service and talk about what that means. We'll see how to use the Hystrix Dashboard to actually visualize circuit status and performance. We'll discuss the idea of Turbine for aggregating results from different Hystrix Protected Services and pulling that into a single Dashboard and then we'll wrap up. As a reminder for the things we're building in this particular module, we're going to have that front end service again and takes advantage of service discovery, 'cause that's part of what Hystrix does. Takes advantage of some load-balancing and takes advantage and of circuit breaker as we call these other back-end services. So that's all we're going to be touching on in this particular module.

Routing Your Microservices Traffic
Hey there, my name is Richard Seroter, and welcome to this next module in a course about coordinating Java microservices. In this particular module, we're going to look at client-side load balancing and proxying requests between services, and that's an important part of coordinating microservices. So, specifically, we'll start talking about the role of routing in microservices, why do you care about that. What are some of the problems with the status quo options you have available? What is Spring Cloud Ribbon all about? How do you configure Spring Cloud Ribbon to use it more effectively? There's lots of customization options, so what can you do with Ribbon? Then we'll jump into Spring Cloud Zuul, a complementary piece. We'll look at creating a Zuul proxy, exploring how you can do different route configurations, see how you can extend Zuul with different filters, and then, finally, wrap up. In this module, we're going to add some additional capabilities, specifically that API gateway capability. In the toll rate lookup service. So we're going to add that with Zuul, we'll see some more advanced cloud load balancing as we go to the fast pass service, and get a full sense of how Ribbon and Zuul work with the rest of the family of Spring Cloud projects.

Connecting Microservices Through Messaging
Hey there, my name is Richard Seroter and welcome to this next module in a course about coordinating Java microservices. In this one, we're going to look at building message delivery capabilities for connecting our microservices, big part of coordination. Spring Cloud Stream as we're going to focus on here is a very fast evolving service, so new things are added all the time. But this module should give you a strong base that should survive this rapid pace of delivery even if things continue to evolve past what I have talked about in the course. So what are we going to cover here? We'll start with the role of messaging in microservices. We'll discuss some of the problem with the status quo. I'll describe Spring Cloud Stream to you and what it does. We'll actually discuss and of course build a streaming application. I'll talk about the role of processors being able to send and receive messages from a component. We'll look at some of the exciting abstractions in Spring Cloud Stream, specifically things like consumer groups as well as doing partition based processing. Again, it doesn't matter which underlying engine you're using, Spring Cloud Stream gives you some nice abstractions. We'll talk a little bit about content types, solve the health and monitoring things for your streaming applications. Then wrap up. We'll continue to plow through our sample application scenario here. In this case, we're going to have the front ends sending messages to a toll intake service. Imagine, I've got all these toll stations collecting readings as cars are driving by. I may want to send those to my backend services through a reliable messaging backend. So we'll build some of those key components here.

Building Data Processing Pipelines Out of Microservices
Hi, there. My name's Richard Seroter. Welcome to this module in a course about coordinating Java microservices. In this module, we're going to look at building data processing pipelines out of the Spring Boot applications. Now, rest assured, Spring Cloud Data Flow could be its own standalone course. I'm going to focus on what it is, standing it up and building some pipelines. It's changing very fast as a technology. It's shipping all the time, which is really exciting. You'll probably see updates soon to how the server behaves, and even the software lifecycle and updating applications. But, even so, this module's going to give you the confidence to use the platform today and tomorrow. Let's jump right in. What are we going to cover together here? Well, first, we're going to talk about the role of orchestration in microservices. What does that mean? As always, what are some of the problems with the status quo here with how we think about this? I'll dig into exactly what Spring Cloud Data Flow is, we'll compare streams and tasks, different types of pipelines that you're going to build and apps you're going to create. Then we'll look at installing Spring Cloud Data Flow, and actually do it together so you have a nice environment to work with. We'll create streams and tasks, which will be exciting. You'll see how these behave and the interfaces for interacting with it. We'll talk about the dashboard, the visual component and flow and the DSL and configuring these things in a visual way. We'll then create composed tasks. This is a newer functionality for doing more chained activities with a set of tasks. Then we'll talk about monitoring and updating pipelines before wrapping up the module, What are adding in this module to wrap up our application? Well, we're going to look at this toll data repository. Let's just assume that each toll station gives me some data, maybe real time, maybe batch. And I want to aggregate that and process through a data pipeline, maybe even looking for fraud and trying to figure out what's going on just in case something bad is happening.