Let's develop a message-driven microservices application

Name: Let's develop a message-driven microservices application
Rating: 4.5 (122 reviews)

Learn how to build scalable applications using multiple frameworks and languages in one knowledge-packed crash course

Created byBernhard Wenzel

Last updated 7/2017

English

English [Auto],

What you'll learn

How to combine several current technologies and frameworks into one multifaceted app
The essentials of front- and backend development, microservices, messaging and more
Each step of the development cycle that goes from an idea to a plan to implementation
How to implement your own solutions during many coding exercises
Without the need to install or configure anything except git and vagrant

Course content

7 sections • 52 lectures • 2h 19m total length

Welcome2:21
Installation2:02
Clone the course content and install vagrant and the virtual machine, run vagrant up, then open localhost to access the coding brain tooter and continue the course.
Summary: installation0:22
How to use this course & Vagrant essentials6:32
Summary: how to use this course1:47

Introduction: from sketch to HTML page1:26
How can we turn a sketch into a HTML page?
Bootstrap essentials2:25
Let's code: bootstrap grid system1:06
Master bootstrap grid fundamentals by building a page layout with a container, rows, and 12-column columns for a results area, following hands-on exercises and example guidance.
Summary: let's code bootstrap's grid system0:09
Solution: bootstrap grid system3:17
Demonstrates building a bootstrap grid system layout with a container and rows, splitting the results area into image and content, then into two rows for tighter and summary, with styling.
Let's code: navbar, forms & buttons0:16
Solution: navbar, forms & buttons3:45

Introduction: interactive websites3:17
In this lesson we answer the question of how we can make websites interactive and what role Knockout plays.
Knockout.js essentials 1: MVVM2:44
This video explains the meaning of the Model-View-ViewModel (MVVM) pattern that Knockout follows.
Knockout.js essentials 2: data binding1:22
This lesson explains how we can bind the view-model to the view.
Let's code: list & search bookmarks3:28
Bind bookmarks and the search query to the index page to show all bookmarks on load and filter results as you search, using foreach and value bindings.
Summary: let's code list & search of bookmarks0:21
Solution: list & search bookmarks3:35
Let's code: add & remove bookmarks0:47
Solution: add & remove bookmarks3:31
Add bookmarks from the euro observable with hard-coded values, then refresh the bookmarks via search, and enable delete and edit of the bookmark summary.
Let's code: edit summary0:39
Solution: edit summary1:39

Introduction2:20
We are going to turn BookieMarker into a real application by adding the backend. In this lesson, we talk about how we could integrate the front- with the backend and what technologies we are going to choose.
REST essentials3:58
In this lesson we talk about:

REST APIs and RESTful applications
Resources
The meaning of “hyper-media driven” and HATEOAS
Spring essentials3:03
What is the Spring framework and Spring Boot? Understanding the difference between dependency management and dependency injection. How to use spring.io’s documentation
Let's code: domain model & REST7:59
Build the bookmark domain model and expose it via a rest API using spring data rest in a spring boot application, configured with Grettel for dependency management.
Summary: let's code domain model & REST API0:45
Solution: domain & REST API3:45
Let's code: search for URL0:44
Solution: search for URL3:12
Implement a contains-based search on the bookmarks repository using a find by query, with case-insensitive matching and a rest endpoint, then validate with get requests and prepare front end integration.
Let's code: integrate frontend9:36
Solution: integrate frontend3:35
Integrate the frontend with Ajax to create, update, and delete bookmarks using POST, PUT, and DELETE requests, serialize the view model to JSON, and load bookmarks to refresh the cache.
Let's code: sorting3:09
Summary: let's code sorting0:16
Solution: sorting3:40
Extend the paging and sorting repository, enhance the bookmark model with creation date, and implement a Spring event handler to preserve order, then add a web scraping service for summaries.

Introduction2:47
Microservices essentials3:58
Explore microservices essentials, including modularity, independent team deployment, and the trade-offs with monolith architectures. Learn synchronous and event-based communication via a message broker with producers and consumers.
RabbitMQ essentials6:38
Master RabbitMQ essentials for a message-driven microservices app. Discover producers, exchanges, queues, bindings, and routing keys, plus direct, fanout, topic, and headers exchange types and the default exchange.
Let's code: webscraper2:05
Code a python web scraper using the newspaper library, create an article object and a scraper class, handle exceptions in a try block, and return a summary and results.
Summary: let's code web scraper0:23
Solution: webscraper2:19
Configure a webscraper for a newspaper library, handle missing results with placeholders, and connect the Python-based scraper to rabbit MQ via a vagrant worker.
Let's code: python RabbitMQ4:14
Summary: let's code python RabbitMQ0:18
Solution: python RabbitMQ5:07
Configure a blocking RabbitMQ connection and channels to create task and result queues, consume scraping tasks, run scrapers, and publish JSON results back to the results queue.
Let's code: integrate the backend5:57
Summary: let's code integrate the backend0:11
Solution: integrate the backend4:53
Configure and wire a text message producer with injected settings to dispatch a task when a new bookmark is created and its scraping results update the bookmark.
Let's code: integrate the frontend1:28
Integrate the frontend with the bookmark scraping workflow to auto-update bookmarks by polling with the setTimeout method, instead of using websockets, and implement this in the frontend view model.
Summary: let's code integrate frontend0:16
Solution: integrate the frontend1:27
Integrate the frontend by implementing polling to refresh bookmarks, handle missing titles, and recheck bookmarks every five seconds, validating updates without reloading.

Requirements

You should have some programming experience
You need Git, Vagrant and Virtualbox installed to follow the lessons

Description

Dive into modern application development while you build a web scraping service from scratch. Understand the whole development process that goes from an idea to a plan to the implementation of a multifaceted application.

Get a profound understanding of many important frameworks and tools in one single crash course.

Web design using Bootstrap
Javascript frontend development using the elegant Knockout.js library
REST API design and hypermedia-driven APIs
Spring & Java backend development
Rapid prototyping with Spring Boot
Microservices architecture
Messaging with RabbitMQ
Web scraping with Python

This class offers a unique distraction-free learning experience that allows you to start coding anytime just by clicking a link

It ships with a virtual machine image that has all requirements installed and a tutoring application that guides you through the course.

Instead of wasting your time with installation or configuration issues that regular courses require, you just open your console and type in "vagrant up". I developed a tutoring application that guides you through the lectures and manages your source code and exercises. You start coding just by clicking a link and having the tutor taking care of the rest.

Most courses either focus on too much theory without practice or are not more than a guided hacking tutorial ignoring deeper concepts. My class delivers the material in a concise form by teaching just enough essentials so you can start coding on your own.

Why watch hours of videos and forget most of it when I can get the same knowledge in a fraction of the time?

Contents and Overview

This course will take you from an idea to a plan to the complete application. We start with the requirements of our application that we have gathered with our fictive client. We plan the development as we would do in a real life software company. Then we develop each part of the application.

We start with the frontend that we implement in two steps. First, we use Bootstrap to layout the website. Second, we make the website interactive using Knockout.js.
Next we move to the backend side and talk about REST API development. Using Spring Boot and Java we demonstrate how to create an API quickly that clients consume.
In the final part of this course, we add a web scraping service to our application. We gain an understanding of the microservices architecture and learn how to increase modularity by taking advantage of messaging with RabbitMQ.

The reason I created this class is that I feel there are not enough offers available for developers who want to maximise the time spent on their education. As software developers, we constantly need to learn something new. Our time is precious. That's why my lectures focus on active coding and teaching what is most important.

As a bonus for my students I personally answer every open question you may have in the forum regarding the course material. My motivation is to help you succeed!

Who this course is for:

Intermediate programmer
Anyone interested in developing an application from scratch
Anyone who wants to build an application and have a base to build upon

Let's develop a message-driven microservices application

What you'll learn

Explore related topics

Course content

Introduction5 lectures • 13min

Planning BookieMarker1 lecture • 3min

The frontend - HTML design7 lectures • 12min

The frontend - interactive websites10 lectures • 21min

The backend13 lectures • 46min

The scraping service15 lectures • 42min

Where to go from here1 lecture • 1min

Requirements

Description

Who this course is for: