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.
- Instructor Led
- Hands-on Lab Environment
- Hardcopy manual
- Microservices Certification
*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.
- Defining Microservices
- Feedback Loops
- Microservices vs Other Architectures
- Revision Control
- Using Vim
- 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.
- Conway’s Law
- Service Oriented Architecture
- Infrastructure as a Service
- Idempotency in Infrastructure
- 12 Factor App
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.
- Service Discovery
- Service Registries
- DNS based Service Discovery
- Configuration Variables
- Legacy Service Connectivity
- Modern Service Connectivity
- Security Considerations
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.
- SQL vs NoSQL
- Volume Storage
- Object Storage
- Cloud Services
- On-Premises Services
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.
- Software Releases
- Configuration Systems
- Associated Services (Prometheus, Graphana, Jaeger, Vault)
- Continuous Integration (Jenkins, Travis, Gitlab)
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.
- Application Specific Servers
- Virtual Machines (VMWare, OpenStack, EC2, Azure, Google Cloud)
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.
- Create, Shorten and Amplify Feedback Loops
- Continued Experimentation
- Working Code Works
- Costs of Microservice Migration
- State Management in Service Design
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.