Developing Microservices Course Details:

Through a focused combination of conceptual lecture and hands-on labs, you will learn what microservices are, when they should be used, then apply that knowledge developing your own microservices application from scratch. Any examples of code used are fully explained in each step, or will be explained by the instructor during the course.

Class includes:

  • Instructor Led
  • Hands-on Lab Environment
  • Hardcopy manual
  • Microservices Certification

    No classes are currenty scheduled for this course.

    Call (919) 283-1653 to get a class scheduled online or in your area!

*Please Note: Course Outline is subject to change without notice. Exact course outline will be provided at time of registration.

You will learn essential microservices concepts and practice common tasks taken to develop microservices in the following sections:

1. Introduction to Microservices and the Development Environment

This section introduces you to the foundations of microservices: What a microservice is, Why organizations have chosen to adopt the microservices model, and How microservices compare to other service architectures. You will perform step-by-step labs, learning ways to efficiently manipulate their microservices development environment.

Core Concepts:

  • Defining Microservices
  • Iteration
  • Feedback Loops
  • Scaling
  • Microservices vs Other Architectures
  • Revision Control

Hands-on labs:

  1. Welcome
  2. Using Vim
  3. Tmux
  4. Revision Control with GitHub

2. Organizational Adoption of Microservices

You will learn design essentials for adopting microservices, viewed from different roles within an organization: Managers, Operations, and Developers. You will start with a monolithic application that you will adapt into a microservice based application. This section teaches you the design steps to complete prior to actually making the conversion to microservices.

Core Concepts:

  • Conway’s Law
  • Service Oriented Architecture
  • Infrastructure as a Service
  • Idempotency in Infrastructure
  • 12 Factor App
  • DevOps

Hands-on labs:

5. Deploying a Monolithic Application
6. Verifying the Application Deployment (running tests)

3. Core abstractions for Microservices - Service Discovery and Connectivity

You will practice with the various additional infrastructure and code that is needed for transforming an application into a replicable service. You will follow a proven process of building and connecting applications to a service registry.

Core Concepts:

  • Service Discovery
  • Service Registries
  • DNS based Service Discovery
  • Configuration Variables
  • Legacy Service Connectivity
  • Modern Service Connectivity
  • Security Considerations

Hands-on labs:

7. Developing a Service Registry
8. Connecting to a Service Registry

4. Core abstractions for Microservices - Databases and Service Runtime

You will be introduced to options available to store the state of services, as well as various ways that services can be hosted with several runtime environments. You will create a microservice and integrate it with the existing monolithic based application.

Core Concepts:

  • SQL vs NoSQL
  • Volume Storage
  • Object Storage
  • Hypervisors
  • Containers
  • Cloud Services
  • On-Premises Services

Hands-on labs:

9. Creating the First Microservice
10. Containerizing the Microservice
11. Integrating the Microservice with the Monolith
12. Verifying the Application Deployment (running tests)

5. Core abstractions for Microservices - Service Definition

You will study configuration, monitoring, and testing options that apply to microservice development. In the labs, you will continue to build microservices and attach them to the monolith.

Core Concepts:

  • Software Releases
  • Configuration Systems
  • Associated Services (Prometheus, Graphana, Jaeger, Vault)
  • Secrets
  • Testing
  • Continuous Integration (Jenkins, Travis, Gitlab)

Hands-on labs:

13. Creating and Containerizing the other Microservices
14. Integrating the other Microservices with the Monolith
15. Verifying the Application Deployment (running tests)

6. Evolutionary History of Containerization

You will directly apply the latest microservices tools to containerize and test microservices in a container-based deployment. You will then deploy your microservice into a Kubernetes environment, completing the conversion from monolith to microservice.

Core Concepts:

  • Application Specific Servers
  • Virtual Machines (VMWare, OpenStack, EC2, Azure, Google Cloud)
  • Docker
  • Docker-Compose
  • Containerd
  • Podman
  • Kubernetes

Hands-on labs:

16. Deploying the Application with Docker Compose
17. Verifying the Application Deployment (running tests)
18. Creating a Container Registry
19. Optimizing Container Images with Podman
20. Deploying the Application with Kubernetes

7. Practical Adoption of Microservices

The final section of the course will summarize the concepts previously covered, as well as discuss the practical implications of designing for, or migrating to, a microservices based architecture.

Core Concepts:

  • Workflow
  • Create, Shorten and Amplify Feedback Loops
  • Continued Experimentation
  • Working Code Works
  • Costs of Microservice Migration
  • State Management in Service Design
  • Encapsulation
  • Segregation
  •  Adoption

For students following the Microservices Developer Course, this course is the third course in the series, following Python Basics and APIs & API Design with Python courses.

This class is targeted for anybody interested in the processes of Microservices; Developers, Operations Staff, Cloud Architects, DevOps and IT Professionals. The lab portion of this class has two paths; one for technical people and one for management.

Ready to Jumpstart Your IT Career?