Containerized Microservices in Node.js

If you’ve been at any conference or talk recently you’ve likely heard about microservices. In this course we will look at what microservices are and what advantages (and disadvantages) they offer. With microservices architects have the responsibility to break their monolithic application into a collection of smaller microservices. This gives the ability to easily scale different parts of an application dependent on system load, or to choose different technologies for different services. With this increase in freedom and functionality we also get increased responsibilities for testing, documentation, and security. We’ll dig into all of these areas and see practical solutions based on our experience.

With our monolithic service broken down into several parts we’ll now want to look at containerization technologies. The student will be provided an introduction to Docker technology. Both how to use Docker in production, as well as how to develop, test, and troubleshoot in Docker will be covered in this course.

Once we have our containerized microservices we’ll dig into how we can deploy these at scale using Kubernetes. We’ll discuss what new problems arise with logging, load balancing, and deploying into such an environment. Our exercises will go through actual solutions to these problems that you can use in your systems.

This course examines how to actually design, develop, test, and deploy microservices in the real world based on our experience with a variety of projects. The course is very hands on and will encourage participants to work through the problems just as they would when they get back to their office.

Audience:

This course is intended for experienced JavaScript developers who have a good understanding of Node.js and Express.js. Perhaps you currently have a monolithic architecture and are interested in moving to a microservice architecture. This course goes past all of the buzzwords and hype and digs into how to implement these ideas in practice.

Prerequisites:

All of the examples and exercises in the course are built with Node.js and Express so it's mandatory that participants have previously attended our Node.js with Express course, or have a similar level of professional experience. Participants are also expected to be proficient with basic Linux command-line tools.

Stephen Lau

Stephen has worked developing sections of the QNX core OS as well as developing drivers in C for use in mobile devices. Also, he has setup a build and integration server for testing of drivers. At Blackberry he worked as a team lead for several concept and demo projects related to mobile UX. He has also successfully lead a creative team to develop a sign language translation concept project, resulting in an international award.

Stephen has experience developing at different layers of the software stack, from low level drivers designed and developed in C to apps written in C++ and Java.  With previous experience in firmware and driver development, rendering engine development, automated testing, and concept development Stephen is comfortable working with both large and small projects.

With a good eye for detail, Stephen has worked closely with both engineering and design teams to implement BlackBerry's rendering engine as well as many projects related to mobile UX.

Stephen has received several provincial and national medals for his work in electronics and robotics, as well as an international developer award for his work on an American Sign Language translation project.

Key skills: C, C++, JavaScript, ReactJS, NodeJS, QNX RTOS, Docker, Microservices

Course content:

    • Introduction to microservices
    • A Node.js and Express.js refresher
    • Swagger documentation
    • Testing microservices
    • Unit testing
    • E2E testing
    • Dealing with multiple microservices
    • Why security in microservices is different
    • JWT - JSON web tokens
    • Introduction to Oauth
    • Protecting routes across microservices
    • Introduction to containerization
    • Introduction to Docker
    • Basic operations
    • Docker Volumes
    • Containerizing our microservice
    • Using Existing containers
    • Using Docker Compose
    • Publishing our containers
    • What is Kubernetes
    • Core Kubernetes concepts
    • Deploying our own registry
    • Writing and applying deployment and service configurations
    • Volumes in Kubernetes
    • Service Discovery
    • Dealing with Secrets
    • Log aggregation using daemon sets and fluentd

Other relevant courses