Edition 0 Updated to asp. Net core 0

Hosting environment
. In Figure 6-1, you see several containers deployed within a single Docker host. 
That would be the case when deploying to a single Docker host with the docker-compose up 
command. However, if you are using an orchestrator or container cluster, each container could be 
running in a different host (node), and any node could be running any number of containers, as we 
explained earlier in the architecture section. 
Communication architecture
. The eShopOnContainers application uses two communication types, 
depending on the kind of the functional action (queries versus updates and transactions): 
•
Http client-to-microservice communication through API Gateways. This approach is used for 
queries and when accepting update or transactional commands from the client apps. The 
approach using API Gateways is explained in detail in later sections. 
•
Asynchronous event-based communication. This communication occurs through an event bus to 
propagate updates across microservices or to integrate with external applications. The event bus 
can be implemented with any messaging-broker infrastructure technology like RabbitMQ, or 
using higher-level (abstraction-level) service buses like Azure Service Bus, NServiceBus, 
MassTransit, or Brighter. 
The application is deployed as a set of microservices in the form of containers. Client apps can 
communicate with those microservices running as containers through the public URLs published by 
the API Gateways. 

---

97 
CHAPTER 5 | Designing and Developing Multi-Container and Microservice-Based .NET Applications 
Data sovereignty per microservice 
In the sample application, each microservice owns its own database or data source, although all SQL 
Server databases are deployed as a single container. This design decision was made only to make it 
easy for a developer to get the code from GitHub, clone it, and open it in Visual Studio or Visual 
Studio Code. Or alternatively, it makes it easy to compile the custom Docker images using the .NET 
CLI and the Docker CLI, and then deploy and run them in a Docker development environment. Either 
way, using containers for data sources lets developers build and deploy in a matter of minutes without 
having to provision an external database or any other data source with hard dependencies on 
infrastructure (cloud or on-premises). 
In a real production environment, for high availability and for scalability, the databases should be 
based on database servers in the cloud or on-premises, but not in containers. 
Therefore, the units of deployment for microservices (and even for databases in this application) are 
Docker containers, and the reference application is a multi-container application that embraces 
microservices principles.