Microservices with ASP.NET Core and Docker

Transform your ASP.NET Core skills by mastering Microservices and Docker, enhancing application scalability, flexibility, and deployment efficiency for .NET developers.

Course Thumbnail

Essential Skills Gained

Checkmark

Understand the principles and benefits of Microservices architecture.

Checkmark

Implement Docker containers and images for scalable applications.

Checkmark

Convert Monolithic applications to Microservices using ASP.NET Core.

Checkmark

Orchestrate and manage Docker containers with Docker Compose.

Format

  • Instructor-led
  • 4 days with lectures and hands-on labs.

Audience

  • .NET Developers
  • Software Architects
  • DevOps Engineers
  • IT Professionals

Description

Microservices provide an architectural pattern that allows applications to be written in a more flexible and re-usable manner.  They offer several benefits such as better re-use, simplified maintenance, ability to handle change requests and business rules changes more easily, independent versioning and deployment of services, increased productivity for new and existing team members, the option to scale out one or more application features, integration between multiple technologies, and much more. These benefits and several others will be discussed throughout the course so that students understand the overall goals of Microservices and where they work well in enterprise-scale applications. Challenges associated with Microservices are also discussed since we believe it’s critical to understand not only the pros, but also the cons and associated challenges. The course starts out with an introduction to Microservices and focuses on key concepts that developers and architects need to know before applying Microservices in their applications. Docker concepts and commands are then covered including the role of images and containers, the need for volumes, and key commands that can be used to work with Docker. From there a discussion of ASP.NET Core MVC and Web API is covered and students will learn how to run ASP.NET Core applications in both Linux and Windows containers. Finally, all of the concepts covered in the course are brought together to show the process of converting a Monolithic application to a Microservices application using ASP.NET Core, RESTful service concepts, and Docker images and containers. This includes actively using Docker commands, writing custom Dockerfiles, creating Docker Compose .yml files to build images and orchestrate containers, running Linux and Windows containers, and more. By the end of the course students will understand the case for Microservices and how they can be implemented.

Calendar icon

Upcoming Course Dates

No upcoming dates. Please check back later.

Course Outline

Download PDF

The Case for Microservices

  1. Overview of Microservices

  2. Microservices vs. SOA

  3. Pros and Cons of Microservices

  4. Client-side vs. Server-side Routing

  5. Planning for Microservices

  6. Microservices Reference Application

Getting Started with Docker

  1. Application Deployment

  2. Shipping with Containers

  3. Getting Started with Docker

  4. Benefits to Developers and DevOps

  5. Overview of Images and Containers

  6. Layered File System

  7. Containers vs. Virtual Machines

  8. Docker and Microservices

Docker Images and Containers

  1. Container Registries

  2. Working with Images

Working with Containers

  1. Getting Started with a Custom Dockerfile

  2. Building an Image

  3. Updating an Image

  4. Pushing an Image to a Registry

Containers and Volumes

  1. Components Overview

  2. Source Code and Containers

  3. Introduction to Volumes

  4. Creating a Volume

  5. Inspecting Volumes

  6. Defining a Volume in a Dockerfile

  7. Local Source Code and Containers

Orchestrating Containers with Docker Compose

  1. Container Orchestration

  2. Getting Started with Docker Compose

  3. The docker-compose.yml File

  4. Docker Compose Commands

Getting Started with ASP.NET Core

  1. Getting Started with ASP.NET Core

  2. Configuration and Middleware Pipeline

  3. Controllers and Views

  4. RESTful Services with Web API

  5. Data Access with Entity Framework Core

  6. OS X Cross Platform Development

ASP.NET Core and Docker

  1. Docker and ASP.NET Core

  2. Creating ASP.NET Core Linux Images

  3. Creating ASP.NET Core Windows Images

  4. Visual Studio Docker Features

  5. “Containerizing” .NET Framework Applications

  6. Running and Debugging Containers

Monolithic to Microservices

  1. Monolithic Applications Review

  2. Microservices Review

  3. Communicating with Microservices

  4. Converting a Monolithic Feature to a Microservice

  5. Creating Dockerfiles and Images

  6. Creating the Docker Compose File

Microservices Orchestration and Monitoring Tools Overview

  1. Docker Swarm

  2. Kubernetes

  3. Marathon

  4. cAdvisor

  5. SysDig

Your Team has Unique Training Needs.

Your team deserves training as unique as they are.

Let us tailor the course to your needs at no extra cost.