Microsoft design document

Cloud implementation - test min. Cloud implementation - deploy and operate min. On-premises implementation - analysis min. On-premises implementation - design and develop min. On-premises implementation - test, deploy, and operate min. Gathering and analyzing the requirements min. Create functional design documents FDD min. You want to take advantage of emerging technologies frameworks, programming languages, etc.

You do not want to make full migrations of the application when moving to new technologies, because that would result in high costs and impact the predictability and stability of the application. What should the application deployment architecture be?

The specifications for the application, along with the development context, strongly suggest that you should architect the application by decomposing it into autonomous subsystems in the form of collaborating microservices and containers, where a microservice is a container. In this approach, each service container implements a set of cohesive and narrowly related functions.

For example, an application might consist of services such as the catalog service, ordering service, basket service, user profile service, etc. Microservices are developed and deployed as containers independently of one another.

This approach means that a development team can be developing and deploying a certain microservice without impacting other subsystems. Each microservice has its own database, allowing it to be fully decoupled from other microservices. When necessary, consistency between databases from different microservices is achieved using application-level integration events through a logical event bus , as handled in Command and Query Responsibility Segregation CQRS.

Because of that, the business constraints must embrace eventual consistency between the multiple microservices and related databases. So that you can focus on the architecture and technologies instead of thinking about a hypothetical business domain that you might not know, we have selected a well-known business domain—namely, a simplified e-commerce e-shop application that presents a catalog of products, takes orders from customers, verifies inventory, and performs other business functions.

The application consists of multiple subsystems, including several store UI front ends a Web application and a native mobile app , along with the back-end microservices and containers for all the required server-side operations with several API Gateways as consolidated entry points to the internal microservices.

Figure shows the architecture of the reference application. Figure The eShopOnContainers reference application architecture for development environment. The above diagram shows that Mobile and SPA clients communicate to single API gateway endpoints, that then communicate to microservices.

Hosting environment. In Figure , 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 application is deployed as a set of microservices in the form of containers. 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. 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. Each microservice can be designed, developed, and deployed independently of other microservices, which provide agility because it is easier to deploy new versions of microservices frequently.

Word Quick Start. Next: Intro to Word. Table of contents Word Quick Start. Use Styles Styles templates apply a consistent font, font size, font color, and spacing to headings, paragraphs, and titling throughout your document. Select the words, paragraph, list or table to edit. On the Home tab, select a style. Apply Themes Themes add a professional look to your document.

Point to a theme to preview how it will look. Select the theme you want. Check spelling and grammar Word marks misspelled words with a red squiggly underline and grammar mistakes with a blue double underline.

Right-click the word. The purpose of REST is to model entities and the operations that an application can perform on those entities. A client should not be exposed to the internal implementation. Entities are often grouped together into collections orders, customers.

A collection is a separate resource from the item within the collection, and should have its own URI. For example, the following URI might represent the collection of orders:. Each item in the collection also has its own unique URI. Adopt a consistent naming convention in URIs. In general, it helps to use plural nouns for URIs that reference collections. It's a good practice to organize URIs for collections and items into a hierarchy. This approach helps to keep the web API intuitive.

Also consider the relationships between different types of resources and how you might expose these associations. However, extending this model too far can become cumbersome to implement.

A better solution is to provide navigable links to associated resources in the body of the HTTP response message. However, this level of complexity can be difficult to maintain and is inflexible if the relationships between resources change in the future. Instead, try to keep URIs relatively simple. Once an application has a reference to a resource, it should be possible to use this reference to find items related to that resource.

Another factor is that all web requests impose a load on the web server. The more requests, the bigger the load. Therefore, try to avoid "chatty" web APIs that expose a large number of small resources. Such an API may require a client application to send multiple requests to find all of the data that it requires. Instead, you might want to denormalize the data and combine related information into bigger resources that can be retrieved with a single request.

However, you need to balance this approach against the overhead of fetching data that the client doesn't need. Retrieving large objects can increase the latency of a request and incur additional bandwidth costs.

Avoid introducing dependencies between the web API and the underlying data sources. For example, if your data is stored in a relational database, the web API doesn't need to expose each table as a collection of resources. In fact, that's probably a poor design. Instead, think of the web API as an abstraction of the database. If necessary, introduce a mapping layer between the database and the web API.

That way, client applications are isolated from changes to the underlying database scheme. Finally, it might not be possible to map every operation implemented by a web API to a specific resource. For example, a web API that implements simple calculator operations such as add and subtract could provide URIs that expose these operations as pseudo resources and use the query string to specify the parameters required.

However, only use these forms of URIs sparingly. The HTTP protocol defines a number of methods that assign semantic meaning to a request. The effect of a specific request should depend on whether the resource is a collection or an individual item. The following table summarizes the common conventions adopted by most RESTful implementations using the e-commerce example. Not all of these requests might be implemented—it depends on the specific scenario. A POST request creates a resource.

The new resource is added to the collection. A POST request can also be used to submit data for processing to an existing resource, without any new resource being created. A PUT request creates a resource or updates an existing resource. The client specifies the URI for the resource. The request body contains a complete representation of the resource. If a resource with this URI already exists, it is replaced. Otherwise a new resource is created, if the server supports doing so.

PUT requests are most frequently applied to resources that are individual items, such as a specific customer, rather than collections. A server might support updates but not creation via PUT. Whether to support creation via PUT depends on whether the client can meaningfully assign a URI to a resource before it exists. The request body specifies a set of changes to apply to the resource.

This can be more efficient than using PUT, because the client only sends the changes, not the entire representation of the resource. Technically PATCH can also create a new resource by specifying a set of updates to a "null" resource , if the server supports this. PUT requests must be idempotent. If a client submits the same PUT request multiple times, the results should always be the same the same resource will be modified with the same values.

However, it doesn't cover every possible detail or scenario. When in doubt, consult the HTTP specifications. As mentioned earlier, clients and servers exchange representations of resources. For example, in a POST request, the request body contains a representation of the resource to create.