Microservices Training

Mastering Microservices

Do you use the monolithic approach for developing your applications? Are you looking for more modularity and decentralization in your codebase? Have you heard companies like Amazon, Netflix and eBay have switched from a monolithic to microservices approach? Everything you need to know about microservices from a beginner to an advanced level will be covered in this training.

Microservice architecture consists of a collection of small, self-contained, autonomous services that encapsulate a single business capability. These services are very small, independent and separate code-bases that are self-deployable. This training focuses on giving a complete hands-on experience developing and deploying microservices. We start off by understanding the basics and architecture of microservices and move towards developing and deploying microservices and also look at the best practices and principles followed for creating microservices. The following topics will be covered in detail:

  • What is a microservice?
  • Understanding the microservices architecture
  • Microservices vs. monolithic approach
  • Understanding the advantages and disadvantages of microservices
  • Interconnectivity in microservices
  • Understanding the relationship between microservices and service-oriented architecture
  • Developing microservices for the cloud (AWS and Azure)
  • Using DDD to design and implement microservices
  • Securing microservices
  • Consuming microservices from a client application
  • Debugging and troubleshooting development issues
  • Deploying microservices
  • Learning best practices and common principles about microservices
  • Context Boundaries
    • Scoping Microservices
    • Refactoring Microservices
  • Communicating Between Services
    • ESB vs AMQP/Streams
    • REST
  • Data Persistence
    • Micro-SQL and NoSQL
  • Security
    • OAuth / OpenID
    • JSON WebTokens
    • Message Routing with Secure Tokens
  • Development Team Dynamics
    • Project Management
    • Testability
    • Two Pizza Teams

The Microservices Technology Stack

An in-depth view of the various technologies used to design, develop, and deploy microservice-based architectures; from developer workstation to cloud data-centers.

  • Self Hosted (Owin/IIS)
  • RabbitMQ / Azure Service Bus
    • Topics, Exchanges
    • Events, Commands
    • Routing
  • Docker
    • Containers and Virtualization
    • Dockerfile
    • Docker Compose
    • Image Repositories
  • Kubernetes
    • Pods, ReplicaSets, StatefulSets
    • Deployments, and Jobs
    • Services, Load Balancers, and Ingress
    • Persistent Volumes
    • Kubectl and Kubedash
    • Introduction to Helm Package Manager

Implementing Microservices in DotNet Core

Building a microservices example platform from the ground-up and orchestrating the containers locally to support the development cycle.

  • Example Application
    • Web Application Front-End
    • Web API Service
    • Auth0 JWT Security
    • Mongo Database or SQL Server
    • Docker Containers
    • Docker Compose Orchestration with VSCode Tasks

Configuring a Development Cluster (optional)

Everything needed to leverage a local Kubernetes server (MiniKube) instead of Docker for development.

  • Minikube Setup
  • Helm Configuration
  • Example Application Deployment
  • Service Ingress Setup

Deploying to the Cloud

Setting up and configuring a production cluster to host our example microservices application.

  • Azure Portal
  • Azure Configuration
    • IAM Contributor
    • App Registration
    • Azure CLI
  • Azure Kubernetes Service (AKS) Deployment
  • Kubctl and Kubedash configuration for remote administration
  • Azure Container Registry
    • Deploying local images to the cloud
  • Kubernetes
    • Architectural Design
    • Operations, Cost, & Concerns for implementing a real-world Development
    • CI/CD pipeline with Kubernetes
    • Configuring the Application Pods
    • Configure Ingress
    • Expose Application via Http

DevOps with Continuous Cloud Deployment (optional)

An overview of DevOps best practices in a containerized environment.

  • Optimized Multi-Stage Docker Builds
  • Integrating docker image pushes into CI Builds
  • Continuous Deployment with Keel and WebHooks


Some of the various technologies that we will touch along the way.

  • Docker
  • Docker-Compose
  • Kubernetes (K8S)
  • Kubernetes Cert Manager
  • Kubernetes on Docker (Edge)
  • Helm
  • Terraform
  • Visual Studio Code Tasks and Launchers
  • Dotnet Core Container Debugger (vsdbg)
  • Powershell / Bash
  • Prometheus
  • Grafana
  • Nginx, Nginx-Ingress
  • Keel Deployments
  • ProGet
  • OpenVPN (into cluster)

Copyright © 2024 Cazton. • All Rights Reserved • View Sitemap