Java Microservices with Spring Cloud: Developing Services

Deliver software faster than ever. This course will teach you core Java microservices patterns including centralized configuration, asynchronous tasks, service authorization, and request tracing.
Course info
Rating
(157)
Level
Intermediate
Updated
Nov 9, 2016
Duration
4h 42m
Table of contents
Course Overview
Introduction to Microservices, Spring Boot, and Spring Cloud
Simplifying Environment Management with Centralized Configuration
Offloading Asynchronous Activities with Lightweight, Short-lived Tasks
Securing Your Microservices with a Declarative Model
Chasing Down Performance Issues Using Distributed Tracing
Description
Course info
Rating
(157)
Level
Intermediate
Updated
Nov 9, 2016
Duration
4h 42m
Description

Developers around the world are delivering software faster thanks to a microservices architecture. In this course, Java Microservices with Spring Cloud: Developing Services, you will learn the skills needed to build Java microservices. First, you'll get an introduction to Microservices, Spring Boot, and Spring Cloud. Next, you'll explore offloading asynchronous activities with lightweight, short-lived tasks. Finally, you'll wrap up the course learning how to chase down performance issues using distributed tracing. When you're finished with this course, you'll have a foundational knowledge of key microservices patterns and be able to use your experience to build better Java microservices.

About the author
About the author

Richard Seroter is a Senior Director of Product for Pivotal, a 10-time Microsoft MVP for cloud/integration, an instructor for developer-centric training company Pluralsight, the lead InfoQ.com editor for cloud computing, and author of multiple books on application integration strategies.

More from the author
More courses by Richard Seroter
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hey everyone, my name is Richard Seroter, and welcome to my course, Java Microservices with Spring Cloud, focused on developing services. I'm really excited about this course, because microservices are all the rage in our industry. Why is that? Well, there's never been a greater premium placed on shipping high quality software quickly. I'm a Senior Director of Product at Pivotal, the company behind the Spring Framework. I'm also a regular Pluralsight trainer, a Microsoft MVP, Infoque. com editor, and a frequent blogger. In this course, we're going to take a deep look at microservices patterns, and how you realize those patterns with Spring Cloud. Spring Boot and Spring Cloud are exploding in popularity, with millions of downloads per month between them, as Java developers are looking to build cutting-edge services. Some of the major things we're going to cover in this course include building a Git-backed configuration store for your app configurations. We're going to look at building asynchronous tasks. Securing microservices can be a challenge, so we're going to explore how to make this happen with OAuth too. We'll also see how you trace microservices, so that we can uncover latency as we're building these services. By the end of the course, you'll know some key microservices patterns, and how to implement them with Spring Cloud. Before beginning this course, you should be familiar with Java, Spring, and general web service development. I hope you'll join me on this journey to learn how to build Java microservices with this course on Spring Cloud at Pluralsight.

Introduction to Microservices, Spring Boot, and Spring Cloud
Hi, my name is Richard Seroter, welcome to this course about developing Java Microservices using Spring Cloud. In this first module, we're going to discuss some of the core concepts of microservices, what Spring Cloud and Spring Boot are all about, and what you need to know to get the most out of this course. I'm a senior director of product for Pivotal, the company behind Spring, Cloud Foundry RabbitMQ, and more, a Microsoft MVP for Microsoft Azure, the lead infoque. com editor for cloud computing, frequent Pluralsight trainer, blogger, and I've written a few books. I'm really thrilled that you've started this course, and I hope you're excited about learning some pretty cutting-edge concepts with me. So, what are we going to be covering here together in this first module? Well, we're going to talk about why are microservices popular in the first place. They're not for everybody, there's going to be circumstances where it doesn't make a ton of sense to do this sort of architecture, but why have they taken hold? Why are people starting to move to this? What are some of those core characteristics of microservices? People can call things whatever they would like, but what are some things that are typically associated with someone doing microservices? We're going to talk about some concerns, we're going to talk about some of the valid objections that someone may have about microservices. We're going to discuss some of the microservices scaffolding with Spring Cloud, and what's in Spring Cloud. We're going to talk through all of the different projects. We'll talk about Spring Boot, which forms a real foundational part of, not just Spring Cloud, but really the Spring framework, and Spring Boot has been a transformational component of that, so we'll cover a little bit about that, and do a demonstration of it together. We'll talk about some of the goals, prerequisites for the course, there's going to be some things you'll want to have on your machine to make sure that these demos run really well and you get the full experience from _____ coding up with Spring Cloud. And then finally, we'll summarize the module. So hopefully this is going to be an exciting walkthrough that really sets you up for the rest of this course.

Simplifying Environment Management with Centralized Configuration
Hi. My name is Richard Seroter. Welcome to the second module in a course about building Java microservices using Spring Cloud. In the last module, we kicked off the course, we talked about some of the values and challenges that come along with microservices, and here we're going to look at the topic of configuration. We're going to start off by talking about the role of configuration in microservices. Why do you need this, where does it add some value? We're going to discuss some of the problem with the status quo, bringing in some of the existing ways we used to do things into a new microservices world, what's the problem with that. We'll talk about Spring Cloud Config, defining it, looking at what it is. We'll look at what does it take to create a configuration server, and of course we'll go ahead and do that in some demonstrations. We'll talk about how you consume these configurations within your application. And then, of course, we'll wrap up.

Offloading Asynchronous Activities with Lightweight, Short-lived Tasks
Hi, my name is Richard Seroter, welcome to this third module in a course about building Java microservices using Spring Cloud. In the last module, we talked about the value of a centralized configuration store, and in this module, we're going to talk about building short-lived microservices. We're going to start off talking about the role of asynchronous processing in microservices, some of the problems you'll experience, though, with the status quo, how you define "serverless" computing, which has become a very popular model, what actually Spring Cloud Task is, and what other Spring projects it integrates with. We'll talk about creating a task, we'll look at the storage options to put the result into so that you actually have a history and an audit trail for the tasks. We'll see some of the options for invoking tasks, how can you choose to kick these off. And then we'll summarize.

Securing Your Microservices with a Declarative Model
Hey there, my name is Richard Seroter. Welcome to this fourth module in a course about building Java microservices with Spring Cloud. In the last module, we talked about short-lived microservices, with Spring Cloud Task. In this one we're going to talk about building secure services using OAuth 2. 0. We'll start off by talking about the role of security in microservices, and a bit to the problem with the status quo approach to security. We'll talk about Spring Security and Spring Cloud security, and how that helps you. OAuth 2. 0 forms a big piece of the security story with Spring Cloud Security, so we'll talk about that. OAuth 2. 0 has a number of flows that come into play, so we'll first look at the authorization code grant type. We'll build a Resource Server ourselves that has secure services hosted on it. We'll then talk about the password credential grant type, and using a different way of authenticating and authorizing. We'll then build our own Authorization Server, which is very easy with Spring Cloud Security. We'll talk about another grant type, the client credential grant type. We'll actually throw some method access rules, saying hey, you have to be in this particular role, or you have to have this sort of claim to be able to access this service. It's a pretty neat way to secure your services. And then we'll talk about a few advanced token options that we can investigate further, and finally wrap things up.

Chasing Down Performance Issues Using Distributed Tracing
Hi there, my name is Richard Seroter, welcome to this fifth module in a course about building Java microservices using Spring Cloud. In the last module, we took a long look at securing microservices. In this module, we're going to look at how you chase down latency issues in the services you've built, which is a big part of building services, is building them with latency in mind, especially in microservices, where you have a lot of different components. So, specifically, we'll start by talking about the role of tracing in microservices. Where does that come into play? What's some of the problems with the status quo that you might already have some things in place, but it might not be sufficient for this microservices world. We'll talk about Spring Cloud Sleuth and what that offers to you. We'll actually look at the anatomy of a trace, or follow the path of a trace through some sample services. We'll talk about what gets automatically instrumented in Spring, thanks to Spring Cloud Sleuth. We'll see how you add Spring Cloud Sleuth to a project, and then do that. Then we'll talk about Zipkin and what it means to visualize latency, and what sort of power that gives you as a developer. We'll then add Zipkin to a solution, building a Zipkin server, and actually have things point to it. We'll work with some custom samplers and see what that looks like when you want to control the sampling rate for traces. We'll look at how you manually create spans and actually inject some of your own things into the automatic tracing that happens with Sleuth, and then we'll wrap up.