Skip to content


Select a date below


Dates are listed in Pacific Time Zone

= Guaranteed to run date


Print Friendly, PDF & Email


Microservice architecture is a brave new world! Companies are abandoning the age-old monolith architecture for a modular approach that supports rapid expansion and compression of services. As your company grows, the more you’ll find a transition to microservices is necessary! Make the journey work for your business by mastering an arsenal of tools to plan, communicate, and manage the transiধon to microservices in a cost effective way. In our labs, you will convert a clumsy monolithic application to agile microservices in a controlled environment. Learn firsthand how and why each step is taken in the orderly decision process of transitioning your environment to 100% microservices!


This course is intended for students who might not have previous development experience.


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.


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 your microservices development environment.

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

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, which you will begin transforming into a microservice-based application. The hands-on labs of this section introduce you to the monolithic application you will be converting, and establish a consistent method to test the application’s performance.
Core Concepts:
• Conway’s Law
• Service Oriented Architecture
• Infrastructure as a Service
• Idempotency in Infrastructure
• Components of a 12 Factor App
• Defining DevOps

3. 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 through the hands-on labs.

Core Concepts:
• Service Discovery
• Service Registries
• DNS based Service Discovery
• Configuraধon Variables
• Legacy Service Connectivity
• Modern Service Connectivity
• Security Considerations

4. 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

5. 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)
• Securing Secrets
• Automated Tesধng
• Continuous Integration (Jenkins, Travis, Gitlab)

6. Deploying and Upgrading Your Microservices

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

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

Hands-on labs:

1. Microservices Design and Engineering: Course Outline
2. Welcome to Alta3 Research Labs
3. Vim: A Modal Text Editor
4. Efficient CLI Usage with Tmux
5. Revision Control with GitHub
6. Deploying a Monolithic Application
7. Verifying the Application Deployment
8. Developing a Service Registry
9. Connecting to a Service Registry
10. Creating Your First Microservice
11. Containerizing Your Microservice
12. Integrating Your Microservice With Your Monolith
13. Creating and Containerizing More Microservices
14. Integrating More Microservices with the Monolith
15. CHALLENGE LAB! Containerize Your Service Registry
16. Inspecting Your Microservice with mitmproxy
17. Install Jenkins
18. Use Jenkins to Test our Code
19. Deploying the Microservices with Docker Compose
20. Creating a Container Registry
21. Deploying the Microservices with Kubernetes

Additional information


3 days

Guaranteed to run