01. Roadmap and Milestones for future releases

Related readme files (use them for more information after reading this)

• https://github.com/dotnet-architecture/eShopOnContainers/blob/dev/branch-guide.md: Branches used and their purpose. Any branch not listed in this file is "temporary" and "unsupported" and can be deleted at any time.

Version 2.0 (Based on .NET Core 2.0)

• Available at the DEV and MASTER branch.

• Docker containers with .NET Core, Linux images and Windows containers supported and tested.

• .NET Core 2.0 and EF Core 2.0 support

• Visual Studio 2017, including VS Docker Tooling based on docker-compose.yml files supporting multi-container debugging, etc. CLI and VS Code environments are also supported.

• CLI build process using a Docker ASPNETCore build-image (microsoft/aspnetcore-build) with all the needed SDKs so the compilation takes place in the same container recommended to be used in your CI pipeline (Continuous Integration). No need to have all dependencies in the dev machine when using this method. Using this CI docker-compose file.

• Microservice oriented architecture, easy to get started, described in this Guide/eBook .

• Support for Windows Containers running on Windows Server Nano using different Docker base images instead of the Linux based images

• INTEGRATION EVENTS with Event Bus implementations: Implement Event-Driven communication between microservices/containers based on Event Bus interfaces and two implementations:

  1. (Implemented as PoC) Standalone Pub/Subs messaging implementation based on an out-of-proc RabbitMQ Container
  2. (Future version) Azure-attached implementation based on Azure Service Bus using Topics for Pub/Subs Two integration event scenarios to implement in the app:
  3. Simple (higher priority): Change Product info (name, image URL, etc.) in the Catalog and update that in the existing Orders and Baskets (all, except the price)
  4. (Future version) Complex: Events propagating Order's states changes related to the Order-Process SAGA (InProcess, Paid, Handling, Shipped, Canceled if timeout because it was not paid, etc.)

• DOMAIN EVENTS: Implement Domain Events which is related but not the same as integration events for inter-microservice-communication. Domain Events are initially intended to be used within a single microservice's Domain, like communicating state-changes between Aggregates, although they could derive to Integration Events if what happened in a microservice's domain should impact other additional microservices. SCENARIOS IMPLEMENTED:

  1. Check price change basket vs. catalog when converting to Order: https://github.com/dotnet/eShopOnContainers/issues/38
  2. Multiple AGGREGATE changes within the same Command-Handler, decoupled by domain events.

• Resiliency Communication: Resilient synchronous HTTP communication with retry-loops with exponential backoff and circuit-breaker pattern implementations to avoid DDoS initiated by clients. Implementation with Polly: https://github.com/App-vNext/Polly/ OSS lib.

• Idempotent updates at microservices, so the same update (like OrderCreation) cannot be executed multiple times. Server must implement operations idempotently. An operation is idempotent if it gets the same result when performed multiple times. Implementing idempotency is domain-specific.

• Exception Handling - ASP.NET middleware extension: Business-Exceptions + Generic-Exception-Handler (ExceptionHandlerHandler)

• Command Validations with MediatR Decorator - FluentValidation https://github.com/JeremySkinner/FluentValidation

• HEALTHCHECKS / Health Check Library (Preview) from the ASP.NET team. It provides: A model of healthcheckresults, A Middleware to return ok/bad, A polling service calling the healthchek service and publishing results (open/pluggable to orchestrators, App Insights, etc.)

• Legacy ASP.NET WebForms client running on a Windows Container (Catalog Manager/Simple CRUD maintenance). Consuming the same Catalog microservice. This is an example of a "lift and shift" scenario.

• Monolithic ASP.NET MVC app (just web app, no microservices) with public area of the eShop (Home page with catalog-view functionality, basically). . Running as a container: https://github.com/dotnet/eShopOnContainers/tree/master/src/Web/WebMonolithic . More advanced layered web app: As segregated project available at: https://github.com/dotnet/eShopOnWeb This app is not using Docker containers, just plain web

• Additional microservice (Marketing and Location microservices) with data stored in MongoDB containers or Azure CosmosDB

Deploying to Azure

• Deployment/support into Kubernetes in ACS (Linux containers tested)

• Deployment/support into Azure Service Fabric (Windows Containers and Linux Containers).

• Azure Storage Blob: Using Azure Blobs to store the Product Images instead of plain files in folders

• Azure Functions: Azure Function microservice (The Marketing feature has an Azure function returning the Marketing Campaign content)

• DevOps: eShopOnContainers scripts/procedures of CI/CD pipelines in Visual Studio Team Services

Previous version 1.0 (Based on .NET Core 1.1)

This is an older version supporting .NET Core 1.1, tagged as v1.0 and available here: https://github.com/dotnet-architecture/eShopOnContainers/releases/tag/netcore1.1

VNext

Other possible features:

• Implement more advanced logging suchs as using Serilog: https://serilog.net/ or the selected approach.

• Azure Event Grid: Implement an additional Event Bus implementation based on Azure Event Grid.

• Azure Functions integrated with Azure Event Grid: Additional event-driven Azure Function microservice (i.e. grabbing uploaded images and adding a watermark and putting it into Azure blobs) - The notification would come from Azure Event Grid when any image is uploaded into a BLOB storage.

• Monitoring/Diagnostics of microservices based on Application Insights with custom perfkeys

• Service Fabric Stateful Service implementation in the SF branch

• Gracefully stopping or shutting down microservice instances - Implemented as an ASP.NET Core middleware in the ASP.NET Core pipeline. Drain in-flight requests before stopping the microservice/container process.

• Real time communication: SignalR Hub microservice/container for real-time communication, like notificating something important that just happened to the user. This feature needs to wait for SignalR to be available in .NET Core 2.1.

• (To be Confirmed) Support for .NET Core 2.0 Razor Pages as additional client app.

• Security:

  • Encrypt secrets at configuration files (like in docker-compose.yml). Multiple possibilities, Azure Key Vault or using simple Certificates at container level, Consul, etc.
  • Other "secure-code" practices
  • Encrypt communication with SSL (related to the specific cloud infrastructure being used)
  • Implement security best practices about app's secrets (conn-strings, env vars, etc.) (However, this subject depends on the chosen orchestrator...) See when using Swarm: https://blog.docker.com/2017/02/docker-secrets-management/

• Create a building block to handle Idempotency in a generic way (Issue 143)

• Implement example of Optimistic Concurrency updates and optimistic concurrency exceptions

• (To be Confirmed) Nancy: Add a Nancy based microservice, also with DocDB, etc.

• (To be Confirmed) Support other DataProtection providers such as AspNetCore.DataProtection.ServiceFabric

• (To be Confirmed) Service Fabric and Actor model, stateful services, etc.

• (To be Confirmed) Guide on Kubernetes • Possible "Getting started guide w/ using minikube and eShopOnContainers" -- For MAC dev machine most of all: Requirements • Possible "Examples using https://github.com/kubernetes/helm"

• (To be Confirmed) In the Windows Containers fork, implement and add a simple WCF microservice/container implementing any logic like a simulated legacy Payment Gateway, as an example of "lift and shift" scenario.

• (To be Confirmed) Semantic log - Semantic logic - Related to the Azure app version and Application Insight usage Monitor what microservices are up/down, etc. related to App Insights, but the events are custom ETW events and "Semantic Application Log" from P&P Multiple implementations for the storage of the events, Azure Diagnostics, Elastic Search. Using EventSource base class, etc.

• (To be Confirmed) Composite UI based on microservices. Including the “UI per microservice”. References on Composite UI with microservices:

  Composite UI using ASP.NET (Particular’s Workshop) http://bit.ly/particular-microservices

  The Monolithic Frontend in the Microservices Architecture http://blog.xebia.com/the-monolithic-frontend-in-the-microservices-architecture/

  The secret of better UI composition https://particular.net/blog/secret-of-better-ui-composition

  Including Front-End Web Components Into Microservices https://technologyconversations.com/2015/08/09/including-front-end-web-components-into-microservices/

  Managing Frontend in the Microservices Architecture http://allegro.tech/2016/03/Managing-Frontend-in-the-microservices-architecture.html

Sending feedback and pull requests

We'd appreciate to your feedback, improvements and ideas. You can create new issues at the issues section, do pull requests and/or send emails to eshop_feedback@service.microsoft.com