Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -9,10 +9,10 @@ ms.date: 02/15/2019

Chapter 1 introduced the fundamental concepts regarding containers and Docker. That information is the basic level of information you need to get started. But, enterprise applications can be complex and composed of multiple services instead of a single service or container. For those optional use cases, you need to know additional approaches to design, such as Service-Oriented Architecture (SOA) and the more advanced microservices concepts and container orchestration concepts. The scope of this document is not limited to microservices but to any Docker application life cycle, therefore, it does not explore microservices architecture in depth because you also can use containers and Docker with regular SOA, background tasks or jobs, or even with monolithic application deployment approaches.

**More info** To learn more about enterprise applications and microservices architecture in depth, read the guide [NET Microservices: Architecture for Containerized .NET Applications](https://docs.microsoft.com/dotnet/standard/microservices-architecture) that you can also download from <https://aka.ms/MicroservicesEbook>.
**More info** To learn more about enterprise applications and microservices architecture in depth, read the guide [NET Microservices: Architecture for Containerized .NET Applications](../../microservices-architecture/index.md) that you can also download from <https://aka.ms/MicroservicesEbook>.

However, before we get into the application life cycle and DevOps, it's important to know how you're going to design and construct your application and what are your design choices.

>[!div class="step-by-step"]
>[Previous](index.md)
>[Next](common-container-design-principles.md)
>[Next](common-container-design-principles.md)
Original file line number Diff line number Diff line change
Expand Up @@ -57,7 +57,7 @@ Because containers are inherently immutable, by design, you never need to worry

Although monolithic apps can benefit from Docker, we're touching on only the tips of the benefits. The larger benefits of managing containers come from deploying with container orchestrators that manage the various instances and life cycle of each container instance. Breaking up the monolithic application into subsystems that can be scaled, developed, and deployed individually is your entry point into the realm of microservices.

To learn about how to “lift and shift” monolithic applications with containers and how you can modernize your applications, you can read this additional Microsoft guide, [Modernize existing .NET applications with Azure cloud and Windows Containers](https://docs.microsoft.com/dotnet/standard/modernize-with-azure-and-containers/), that you can also download as PDF from <https://aka.ms/LiftAndShiftWithContainersEbook>.
To learn about how to “lift and shift” monolithic applications with containers and how you can modernize your applications, you can read this additional Microsoft guide, [Modernize existing .NET applications with Azure cloud and Windows Containers](../../modernize-with-azure-and-containers/index.md), that you can also download as PDF from <https://aka.ms/LiftAndShiftWithContainersEbook>.

## Publish a single Docker container app to Azure App Service

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -71,8 +71,8 @@ Different orchestrators might sound similar, but the diagnostics and health chec
[*https://www.splunk.com/*](https://www.splunk.com/)

- **EventSource Class** API for events tracing for Windows (ETW) \
[*https://docs.microsoft.com/dotnet/api/system.diagnostics.tracing.eventsource*](https://docs.microsoft.com/dotnet/api/system.diagnostics.tracing.eventsource)
[*https://docs.microsoft.com/dotnet/api/system.diagnostics.tracing.eventsource*](xref:System.Diagnostics.Tracing.EventSource)

>[!div class="step-by-step"]
>[Previous](microservice-based-composite-ui-shape-layout.md)
>[Next](scalable-available-multi-container-microservice-applications.md)
>[Next](scalable-available-multi-container-microservice-applications.md)
Original file line number Diff line number Diff line change
Expand Up @@ -105,7 +105,7 @@ public class PrimeWebDefaultRequestShould
[*https://docs.microsoft.com/aspnet/core/test/integration-tests*](https://docs.microsoft.com/aspnet/core/test/integration-tests)

- **Unit testing in .NET Core using dotnet test** <br/>
[*https://docs.microsoft.com/dotnet/core/testing/unit-testing-with-dotnet-test*](~/docs/core/testing/unit-testing-with-dotnet-test.md)
[*https://docs.microsoft.com/dotnet/core/testing/unit-testing-with-dotnet-test*](../../../core/testing/unit-testing-with-dotnet-test.md)

- **xUnit.net**. Official site. <br/>
[*https://xunit.github.io/*](https://xunit.github.io/)
Expand All @@ -123,7 +123,7 @@ public class PrimeWebDefaultRequestShould

As noted earlier, when you test multi-container applications, all the microservices need to be running within the Docker host or container cluster. End-to-end service tests that include multiple operations involving several microservices require you to deploy and start the whole application in the Docker host by running docker-compose up (or a comparable mechanism if you are using an orchestrator). Once the whole application and all its services is running, you can execute end-to-end integration and functional tests.

There are a few approaches you can use. In the docker-compose.yml file that you use to deploy the application at the solution level you can expand the entry point to use [dotnet test](https://docs.microsoft.com/dotnet/articles/core/tools/dotnet-test). You can also use another compose file that would run your tests in the image you are targeting. By using another compose file for integration tests that includes your microservices and databases on containers, you can make sure that the related data is always reset to its original state before running the tests.
There are a few approaches you can use. In the docker-compose.yml file that you use to deploy the application at the solution level you can expand the entry point to use [dotnet test](../../../core/tools/dotnet-test.md). You can also use another compose file that would run your tests in the image you are targeting. By using another compose file for integration tests that includes your microservices and databases on containers, you can make sure that the related data is always reset to its original state before running the tests.

Once the compose application is up and running, you can take advantage of breakpoints and exceptions if you are running Visual Studio. Or you can run the integration tests automatically in your CI pipeline in Azure DevOps Services or any other CI/CD system that supports Docker containers.

Expand Down Expand Up @@ -205,4 +205,4 @@ As you can see, these docker-compose files only start the Redis, RabbitMQ, SQL S

> [!div class="step-by-step"]
> [Previous](subscribe-events.md)
> [Next](background-tasks-with-ihostedservice.md)
> [Next](background-tasks-with-ihostedservice.md)
Original file line number Diff line number Diff line change
Expand Up @@ -23,9 +23,9 @@ Clearly, if your goal is to have an application (web app or service) that can ru

[Visual Studio for Mac](https://www.visualstudio.com/vs/visual-studio-mac/) is an IDE, evolution of Xamarin Studio, that runs on macOS and supports Docker-based application development. This should be the preferred choice for developers working in Mac machines who also want to use a powerful IDE.

You can also use [Visual Studio Code](https://code.visualstudio.com/) (VS Code) on macOS, Linux, and Windows. VS Code fully supports .NET Core, including IntelliSense and debugging. Because VS Code is a lightweight editor, you can use it to develop containerized apps on the Mac in conjunction with the Docker CLI and the [.NET Core command-line interface (CLI)](https://docs.microsoft.com/dotnet/core/tools/?tabs=netcore2x). You can also target .NET Core with most third-party editors like Sublime, Emacs, vi, and the open-source OmniSharp project, which also provides IntelliSense support.
You can also use [Visual Studio Code](https://code.visualstudio.com/) (VS Code) on macOS, Linux, and Windows. VS Code fully supports .NET Core, including IntelliSense and debugging. Because VS Code is a lightweight editor, you can use it to develop containerized apps on the Mac in conjunction with the Docker CLI and the [.NET Core command-line interface (CLI)](../../../core/tools/index.md). You can also target .NET Core with most third-party editors like Sublime, Emacs, vi, and the open-source OmniSharp project, which also provides IntelliSense support.

In addition to the IDEs and editors, you can use the [.NET Core CLI](https://docs.microsoft.com/dotnet/core/tools/?tabs=netcore2x) tools for all supported platforms.
In addition to the IDEs and editors, you can use the [.NET Core CLI](../../../core/tools/index.md) tools for all supported platforms.

## Using containers for new ("green-field") projects

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -148,7 +148,7 @@ public static async Task CheckStockPrice([OrchestrationTrigger] DurableOrchestra
## Recommended resources

* [Azure Durable Functions](https://docs.microsoft.com/azure/azure-functions/durable-functions-overview)
* [Unit Testing in .NET Core and .NET Standard](https://docs.microsoft.com/dotnet/core/testing/)
* [Unit Testing in .NET Core and .NET Standard](../../core/testing/index.md)

>[!div class="step-by-step"]
>[Previous](durable-azure-functions.md)
Expand Down