Microservices is one of the hottest application development topics in the industry today. To get you started, the Red Hat Developer Program and Global Learning Services teams have collaborated in this curated set of learning material that you can either consume and learn as you need, or go through sequentially for a complete learning experience. As a Red Hat Developer Program member, you have access to all of this. We welcome your feedback - often.
Background and/or familiarity with application development.
Helloworld Microservices Introduction
Our Microservices Playground: 6 different microservices, each using a unique Java framework: Dropwizard, Spring Boot, WildFly Swarm, JBoss Enterprise Application Platform, Node.js, Vert.x. Leveraging Docker+Kubernetes+OpenShift running in a Red Hat Enterprise Linux (RHEL) VM. Microservices Slide Presentation http://bit.ly/helloworldmsa Demo Source Organization https://github.com/redhat-helloworld-msa Download the RHEL VM for Docker+Kubernetes+OpenShift (CDK) http://developers.redhat.com/products/cdk/docs-and-apis/
Microservices & you: Practical Introduction
This session introduces the basic ideas behind microservices, covers the pros and cons of them, and gets started on building your first one. FULL ABSTRACT: Curious about microservices? Want to hear what happens when you actually use them in your environments? This session introduces the basic ideas behind microservices and goes on to discuss some pros and cons of using them. We’ll discuss the process I went through in constructing http://wwww.flatfluffy.com, a multi-device application for gamified recording of roadkill. We’ll review the code and tools used to run the whole application, with a focus on how a microservices architecture was used to produce the mapping experience in FlatFluffy. Join this informal, interactive session where you’ll have the opportunity to ask your implementation questions. Come in curious, and leave with a solid understanding of how to get started on your first microservice-architected application.
Containers Cheat Sheet
Easy to use shortcuts for developers Whether you are new to Containers or have experience, you may find yourself encountering tasks you haven’t done lately. That is where the cheat sheet can help. In this Containers Cheat Sheet find: Introduction to Container architecture Engine, image, registry, volume, related commands Example of running a web server container Save this cheat sheet or print to take it with you.
Kubernetes Cheat Sheet
Kubernetes is an open-source platform for automating deployment, scaling and operations of application containers across clusters of hosts, providing container-centric infrastructure. Learn how to Install Minikube Run locally on Minikube Install Kubectl Use the Kubectl CLI Also, see why you’ll need more than Kubernetes for DevOps. Created by Red Hat’s own Daniel Oh for your ease.
DevNation Live | KubeBoot: Spring Boot deployment on Kubernetes has never been so easy
A DevNation Live session. Have you ever thought how to deploy Cloud Native Java Applications (Spring Boot) on Kubernetes? Kubernetes has now become a de-facto standard for deploying Cloud Native Applications, but still there is myth that they are not ready for Java workloads. The aim of this session is to break that myth to show Kubernetes is well suited for Cloud Native Java applications. The session starts with a brief history of Microservices; the framework, the libraries, the platform and the tools that have been part of every cloud native applications and how they become deprecated with Cloud Native Java applications deployed to Kubernetes. The session explores the cloud native characteristics such as Discovery, Blue/Green Deployments, Elasticity, Canary Deployments, Resiliency, Pipeline(CI/CD), Authentication etc., becomes implicit characteristics to your Spring Boot Java applications that are deployed on Kubernetes/OpenShift. In this session, we will see how to build, debug, deploy and discover Spring Boot applications on Kubernetes, covering in depth details of the tools, libraries and platform that could be used to make your spring boot deployment smooth and easy. Speaker: Kamesh Sampath Kamesh is currently Red Hat's Director of Developer Experience, most part of Kamesh's career was with services industry helping various customers build Java based solutions. Kamesh is the creator of vertx-maven-plugin(https://vmp.fabric8.io) and he has been an active contributor to fabric8 project. Being a OpenSource developer and contributor Kamesh's loves sharing his experience on building and deploying Java Applications on Kubernetes/OpenShift. He still loves to learn new technologies and strongly believe in 'ITS BETTER TO SHARE'.
Decomposing A Java EE Monolith Into WildFly Swarm Microservices
In this session we'll introduce you to WildFly Swarm through the migration of TicketMonster from a Java EE monolith to Java EE microservices for parts of the stack. The services will be discoverable, provide failover with Netflix Ribbon, and utilize Netflix Hystrix for circuit breaking. TicketMonster, a full Java EE application, will be dissected into appropriate services while also retaining Java EE pieces that are appropriate. We'll then walk through several required aspects for a full services architecture. This will include securing these services with Keycloak; registering services for discovery via JGroups, Consul or Zookeeper; service logging to external sources such as logstash; and capturing service metrics with Hawkular and DropWizard Metrics. By the end of the session, we'll have converted some pieces of a Java EE application into services, while learning how WildFly Swarm integrates with external tools to provide a complete solution for service delivery.
MicroProfile - Microservices with Java EE
A DevNation Live session. Developers have a tremendous amount of Java™ EE and general Enterprise Java knowledge and skill that they want to use as they evaluate the adoption of a cloud-native architecture. MicroProfile is a baseline platform definition that optimizes Enterprise Java for a microservices architecture and delivers application portability across multiple MicroProfile runtimes. This encompasses a growing collection of specifications that address microservice patterns like fault tolerance, configuration, metrics, health check, security, and more. Join this webinar to learn the current state of progress within the MicroProfile community.
Microservices for Java Developers: A Hands-on Introduction to Frameworks and Containers
The Microservice architectural approach is more than just about technology. It reaches into the foundation of your organization to allow you to build truly scalable, adaptive, complex systems that help a business adapt to rapidly changing competitive markets. Using a hands-on approach to three useful Java frameworks for building Microservices: Spring Boot, Dropwizard, and WildFly Swarm you can compare and contrast them through a handful of familiar patterns, including: Exposing a service Configuration at runtime Exposing metrics/insight Calling downstream services in a safe manner Explore concepts like immutable delivery and how Linux Containers and Kubernetes can be used to deploy and manage Microservices.
DevNation Live | Kubernetes for Java developers
Developers are becoming more familiar with Linux containers each day, but have you really ever thought about how to manage a fleet of containers? Hundreds or thousands of containers? Kubernetes from Google has become the "de facto" standard for container orchestration. This brief session will provide you with a basic understanding of what Kubernetes is and how it can help you run your Linux containers at scale. After this session, you will only want to deploy your Java applications and microservices on Kubernetes! This is a DevNation Live recorded session.
Building Reactive Microservices in Java: Asynchronous and Event-Based Application Design
Investigating distributed microservices? Want to get rid of your monolithic enterprise applications or not create new ones? Reactive design can help. Author and Red Hatter, Clement Escoffier, explains why and how Eclipse Vert.x is a good choice to build effective microservices systems. In this O’Reilly book learn how: Explore the elements of reactive microservices and learn how Vert.x works. Build and consume a single microservice to understand how messaging improves its reactiveness. Create an entire microservices system, using stability and resilience patterns to manage failures. Use the OpenShift container platform to deploy and manage microservices in a virtual or cloud environment.
The Reactive Landscape - Clement Escoffier
Migrating to Microservice Databases: From Relational Monolith to Distributed Data
Code is easy, State is hard. Learning how to deal with your monolithic relational databases in a microservices structure is key to keeping pace in a quickly changing workplace. There are many approaches and in this book, author Edson Yanaga, takes you through nine different strategies for integrating data from your monolithic application to a microservice architecture. In this O’Reilly book learn how: zero downtime migrations allow you to deploy new code without disrupting user activity you can evolve your relational database by keeping specific versions of application code and database schemas in the same code repository CRUD pattern and CQRS works and the differences between them—including the consistency models involved in distributed systems to distribute and integrate your relational database into Microservices
Update your Database Schema with Zero Downtime Migrations
A DevNation Live session. You joined the DevOps movement and want to release software even faster and safer. And how do you achieve this multiple times per day without disrupting your users in production? With Zero Downtime! But what about my data? What about my relational database schema? Join us on this session and we’ll show that with code might be “easy”, and data may be “hard”, but it’s definitely possible and practical.
Modern Java EE Design Patterns: Building Scalable Architecture for Sustainable Enterprise Development
With the ascent of DevOps, microservices, containers, and cloud-based development platforms, the gap between state-of-the-art solutions and the technology that enterprises typically support has greatly increased. But as explained in this O’Reilly report, some enterprises are now looking to bridge that gap by building microservice-based architectures on top of Java EE. Can it be done? Is it even a good idea? This report thoroughly explores the possibility and provides savvy advice for enterprises that want to move ahead. The issue is complex: Java EE wasn’t built with the distributed application approach in mind, but rather as one monolithic server runtime or cluster hosting many different applications. If you’re part of an enterprise development team investigating the use of microservices with Java EE, there are several items to consider: Understand the challenges of starting a greenfield development vs tearing apart an existing brownfield application into services Examine your business domain to see if microservices would be a good fit Explore best practices for automation, high availability, data separation, and performance Align your development teams around business capabilities and responsibilities Inspect design patterns such as aggregator, proxy, pipeline, or shared resources to model service interactions
You've Got Microservices... Let's Secure Them
You went ahead a built a whole new set of shiny microservices. While doing this, you realized you can no longer rely on your application server to handle all the authentication. Oh, and of course, one of your teams used Node.js. How are you going to secure all these endpoints so that the end user doesn’t have to authenticate against each one. In this session, we'll give a demonstration of using a centralized authentication service to secure many different microservices. The demo will be based on Project Keycloak, but it would apply as well to Stormpath, Ping.Indenty, or similar services.
Developing Cloud-Native Applications with Microservices Architectures
This Red Hat Training course (DO092) encapsulates a series of Red Hat produced, on-demand online videos that will teach you about microservices frameworks, tools, and architectures.