Get started building microservices with ASP.NET Core and Docker in Visual Studio Code (2023)

Get started building microservices with ASP.NET Core and Docker in Visual Studio Code

Published December 19, 2017 • Updated March 7, 2020

Containers and microservices are twohugeNew trends in software development.

For the uninitiated, containers are a great way to package an application, its dependencies, and settings into portable, easily distributable image files. This image can then be downloaded and run in a runtime environment called a container on any number of other computers that will host the container. Microservices represent an architectural style in which a system can be decomposed into individual services, each with a specific and unique mobile devices) public.

By looking at the characteristics of these two concepts, we can begin to understand why they work so well together, helping us develop systems that are easier to deploy, scale, maintain, and provide a higher level of stability than traditional monolithic approaches.

Two key design elements of .NET Core are modularity and lightweight. These characteristics make it ideal for developing containerized microservice applications. In this article, we'll see how to combine ASP.NET Core and Docker using a cross-platform approach to build, debug, and deploy a microservices-based proof-of-concept using Visual Studio Code, the .NET Core CLI, and the Docker CLI.

Please note- Both topics, microservices in particular, are long and deep, so there are many very important aspects that I will briefly cover or not mention here at all. The purpose of this post is to get started with ASP.NET Core and Docker based microservices. some of the most critical andChallenging Exercises in Microservice ArchitectureThe domain and data model can be correctly identified and defined,limited contextand their relationship. This post will not delve into design theory and modeling. Likewise, with containers, there are many other important areas that we won't explore in this guide, such as container design and orchestration principles.

development environment

• Windows 10 和 PowerShell
• Visual Studio Code - Version 1.19.0
  • C# for Visual Studio Code extensions
  • Pluggable extension
• SQL Server Management Studio 17.4
• .NET Core SDK v2.0.0
• Docker Community Edition 17.09.1-ce-win42 usando contenedores Linux

Solution configuration

Starting with an empty directory, you can create a new solution using the .NET Core CLI.

> dotnet 新 sln --name dotnetgigs

In the same directory, I created a file namedServeTo accommodate the microservices we will use:Applicant.Api,identity.apiIwork interface.

In each microservice directory, I created a new Web API project. Note that you can omit the name parameter and the new project will inherit the name of the parent directory.

> dotnet new webapi

Then I add each project to the solution file I created earlier:

> dotnet sln dodaj services/requesters.api/requesters.api.csproj

> dotnet sln dodaj services/jobs.api/jobs.api.csproj

> dotnet sln dodaj services/identity.api/identity.api.csproj

hello docker

At this point, we'll step away from code for a while and integrate Docker into our solution and workflow.

One thing to know: Because we use Visual Studio Code and the CLI development approach, we need a more detailed understanding of the many steps involved in using Docker than we do with Visual Studio. Visual Studio 2017 has great built-in Docker support, so it offers increased productivity and avoids the immediate clutter of Docker files and CLIs. On the other hand, Visual Studio Code is not yet complete and needs a more hands-on approach. For our purposes, the CLI approach we'll use still has a lot of value, as it provides a better understanding of the tools and processes involved in building Docker with .NET Core. These steps are also largely cross-platform, as they should work in a Mac or Linux environment with little customization required.

Create a debuggable container

One area where current developer experience with Docker is particularly lacking in Visual Studio Code compared to Visual Studio is debugging. We want to be able to debug our service while running on Docker. At first I wasn't sure what to do, but some google popped upthis thread(ThanksGalvi Ribeiro) and the following Dockerfile:

Z 微软/aspnetcore:latestRUN mkdir app#Install debuggerRUN apt-get updateRUN apt-get install curl -y unzipRUN curl -sSL https://aka.ms/getvsdbgsh | bash /dev/stdin -v last -l /vsdbgEXPOSE 80/tcp#Zachowaj kontener debuggera na PUNKTIE WEJŚCIA ["cola", "-f", "/dev/null"]

Here's what's happening:

From microsoft/aspnetcore: Finally

This command just tells Docker to use Microsoft's official aspnetcore runtime image as a base. This means our microservice image automatically provides the .NET Core runtime and required ASP.NET Core librariesstartASP.NET Core application. if we wantput upOur application is in a container and we have to base it onaspnetcore buildimage because it comes with the full .NET Core SDK required to develop and publish applications. So when choosing a base image keep in mind that they are optimized for different uses, so we need to look for images that are suitable for our intended use to avoid unnecessary bloat with custom images. You can find more information about the official ASP.NET Core images atMicrosoft ASP.NET Core Docker Hub repository page.Also note that we are using a Linux based image according to the docker setup.

#Install debuggerRUN apt-get updateRUN apt-get install curl -y unzipRUN curl -sSL https://aka.ms/getvsdbgsh | bash /dev/stdin -v najnowsze -l /vsdbg

This section installs the VSCode debugger in the container so we can remotely debug containerized applications from within Visual Studio Code; more on this soon.

#Save debugger container at ENTRYPOINT ["tail", "-f", "/dev/null"]

heentry pointThis command allows you to specify which executable should be run when the container starts. Usually if we just run ASP.NET Core application directly it looks like thisentrypoint ["dotnet", "myaspnetapp.dll"]Run our application using the CLI. Since this container is used for debugging, we want to be able to start/stop the debugger and our application without having to stop and restart the entire container every time the debugger is started. To achieve this, we useogon -f /dev/nullasentry pointThis allows the debugger to start and stop in the background, but doesn't stop the container because the queue runs indefinitely in the foreground.

I added the samedocker fileto the project root directory of each microservice.

Orchestrate multi-container solutions with Docker-Compose

It is relatively easy to process a single Dockerfile using CLI commandsput upIstartCreate an image and run a new container. However, as your solution grows to include multiple containers, dealing with a set of docker files in this way becomes painful and error-prone. To make life easier we can useDocker-ComposeWrap these commands together with per-container configuration data to define a set of related services that can be deployed together as a multi-container Docker application.

After adding the Dockerfiles to each microservice project, I created a newDocker-Compose.ymlfile in the root directory of the solution. We'll expand on this later, but you'll find it simple at first.YAMLBased on a file with a section defining each service of our application and some directives to tell docker how we want it to build and configure our containers.

version: "3" service: applicants.api: image: applicants.api build: context: ./services/applicants.api dockerfile: Dockerfile.debug port: - "8081:80" volume: - ./services/applicants.api /bin/pub/:/app containername:requester.api identity.api:image:identity.api build:context: ./services/identity.api dockerfile:dockerfile.debug ports:- "8084:80" volumes:- . /services/identity.api/bin/pub/:/app containername: Identity.api jobs.api: image: jobs.api build: context: ./services/jobs.api dockerfile: Dockerfile.debug ports: - "8083 : 80" roll:- ./services/jobs.api/bin/pub/:/app container_name: jobs.api

This is what these options do:

• image- The name of the image from which to start the container. When specified in the build directive, Docker-Compose will use this as the name when building the image.
• put up- contains the path to the docker file to use, andcontextDocker should be used to build containers.
• port- It exposes ports to the host and exposes them to various services run by docker-compose. Basically, it provides network connectivity so that we can communicate with services running in containers by assigning ports on the host machine.
• roll- It allows us to mount paths on the host machine inside the container. In our case, this is especially useful for debugging support. As you can see, we point to the published output of the application's bin directory./services/jobs.api/bin/pubto the marked volume/ applicationContainers have access to. This allows us to rebuild our application and run the debugger from Visual Studio Code without touching the container - Radial!
• container name- Allows us to specify a custom container name instead of the generated default.

add database

Now that we have defined the basic microservices for our solution, we can start thinking about our application's data. Microsoft recently releasedSQL Server on Linuxand associated docker images, so this is a good opportunity to try it out. SQL Server on Linux: What a Good Time! I believedatabasefolder in the root of the solution and a new Dockerfile downloaded from the official Microsoft image. You'll also notice the extra bit in the Dockerfile to runSqlCmdStartup.shscript. This script exposes the database required by our microservice. In the end I extended it withdocker-compose.ymlfile to contain the new service. Note that I'm mapping a local port5433Connect to the Sql server's TCP port so I can use Sql Server Management Studio on my desktop to communicate with the database running in the container - Radial! You'll want to do the same if you have a local sql server instance running.

...sql.data: image: mssql-linux build: context: ./Database dockerfile: Dockerfile 端口: - "5433:1433" nazwa_kontenera: mssql-linux

Putting databases in containers is generally not recommended for production use; however, there are exceptions to every rule, so if you are considering production, you should thoroughly test and evaluate each containerized database.

Add a data access layer to microservices

We communicate with the containerized Sql server from our application in exactly the same way as a normal installation. However, Docker provides a way to identify it as a dependency by adding a filedepends on depends onA key for each service indocker-compose.ymlUse its documentation. This is a handy way to manage dependencies between services when using Compose.

...jobs.api: ...depends on:- sql.data

This tells docker to create and run the file.Danish SQLfront containertask.api.

Since this is a very small and simple demo, the data access code is very simple and can be usedelegantThe ORM interacts with the database. CheckApplicationRepository.cslubricantJobRepository.csclass to see how it is implemented.

Use Redis cache

Caches are an essential part of any distributed system. We will add a Redis instance to our architecture that the Identity.Api microservice can use as a backing store for user/session information. This only requires 2 new linesdocker-compose.ymlBoom: we have a redis instance. We don't need any additional dockerfile or configuration for this service.

... user data: image: redis

Redis cache is mainly used byIdentity Vault.You can see where the client connection is established and connected to the container atstart.csThis is in turn injected into the repository. Finally, on startup, you'll notice that the redis host address has been resolved for the connection using the configuration provider:

config.EndPoints.Add(Config["RedisHost"]);

What's special about it is that the value is set todocker-compose.ymladd orenvironmentThe key defined by the Identity.Api service and passed when the container starts. This is also used to pass connection strings to services that use the database.

...identity.api: image: identity.api 环境: - RedisHost=user.data:6379...

Event-based communication between microservices using RabbitMQ and MassTransit

An important principle of microservice architecture is that each microservice should own its own data. In a traditional monolithic application, we usually have a centralized database where we can retrieve and modify entities across the application, usually in the same process. In microservices, we don't have that freedom. Microservices are self-contained and run in their own process. So we can use a message bus to publish and consume messages between microservices if entity changes or other important events happen in microservices that need to communicate with other interested services. This keeps our microservices completely decoupled from each other and from any other external systems they may integrate with.

To add messages to the solution, I first added a RabbitMQ message broker wrapper by extendingdocker-compose.yml:

...rabbitmq: 图片: rabbitmq:3-portmanagement: - "15672:15672" nazwa_kontenera: rabbitmq...

Then publish and consume messages to the microservices I decide to usecollective transportThis is a lightweight message bus framework that works with RabbitMQ and Azure Service Bus. You could also use the raw rabbit client, but MassTransit provides a very friendly rabbit abstraction. One of the shortcuts I took was to not create a single component to represent the event bus in each microservice.start.csYou can see that the bus instance has been created and registered with the container.

builder.Register(c =>{ return Bus.Factory.CreateUsingRabbitMq(sbc => { sbc.Host("rabbitmq", "/", h => { h.Username("gość"); h.Contraseña("gość ) "); }); sbc.ExchangeType = ExchangeType.Fanout; });}).作为(). as(). as().Single instance();

After that, publishing on Rabbit is a piece of cake. In our case, just inject the bus instance into the controller and you can publish events. An example of this istask controllerw jobs. api.

[HttpPost("/api/jobs/applicants")] public asynchronous taskPost([FromBody]JobApplicant model){ // Get job data var job = await _jobRepository.Get(model.JobId); var id = wait _jobRepository.AddApplicant(model); // Send event message "ApplicantApplied" to wait for _bus. Publish(new {model.JobId, model.ApplicantId, job.Title}); return ok(identifier); }

Consuming events is also simple. MassTransit provides a nice mechanism to define the recipients of a message through itsconsumerThe interface where our message code lives.

An example of this can be seen in Identity.Api where the message consumerapplicant reportThe event is defined inEvents used by RequesterConsumer.These consumer classes can be registered in the Autofac container and automatically invoked by MassTransit via some additional bus instance configurations that we register in the container.

// Register a specific Consumerbuilder.RegisterType();builder.Register(context =>{ var busControl = Bus.Factory.CreateUsingRabbitMq(cfg => { var host = cfg.Host(new Uri("rabbitmq:// rabbitmq/"), h => { h. Nombre de usuario("gość"); h.Contraseña("gość"); }); // https://stackoverflow.com/questions/39573721/disable-round-robin-cfg.ReceiveEndpoint(host, "dotnetgigs") + Guid .NewGuid().ToString(), e => { e.LoadFrom(contexto); });});return busControl ;}).SingleInstance().As(). as();

if you look inEvents used by RequesterConsumerclass you'll find it's not very useful. It just increments the value in the redis cache, but it clearly illustrates how event-based asynchronous communication between microservices works.

Asynchronous public task consumption (ConsumeContextcontext){ // increase the number of user applications in the cache await _identityRepository.UpdateUserApplicationCountAsync(context.Message.ApplicantId.ToString());}

Using microservices in an ASP.Net Core MVC web application

To use our microservices and complete the DotNetGigs demo application, I added a newASP.NET Core MVC applicationsolve. The most common method for web and mobile client applications to communicate with microservices is through HTTP, usually viaAPI Gateway.We don't use doors in this demo, but I made a simpleclient httpThis way mvc application can communicate directly with different microservices. The scope of the app's functionality is captured in the animated gif above: you can download a list of job opportunities from Jobs.Api, users can apply, other microservices send and process messages, and that's it!

Compilation and debugging of the solution.

From the project's root folder (wheredocker-compose.ymlreside) build and run containers for the solution using the Docker CLI:PD> docker-compose up -d.This step will take a few minutes or longer as all base images need to be downloaded. Once done, you can check everything out.7The solution's container was created and ran successfully by runningPS> docker ps.

Additionally, you can use SQL Server Management Studio to connect to a containerized Linux Sql Server instance to configure the database.dotnetgigs.applicationsIdotnetgigs.jobswas made. The server name is:localhost,5433with your usernameThatand passwordpassword.

At this point, you can run and debug your solution from within Visual Studio Code. Just open the root folder in VSCode and run each project in the debugger. Unfortunately, they have to be executed one at a time (let me know if you know a solution :) The order in which they are executed does not matter.

renew:Thanks to Burhan below for pointing out how easy it is to run all projects at once.complex launch configuration.The sample code has been updated with your suggestion so you can run all projects in the solution at once by selectingall itemsConfigured in VSCode debugger. Thanks Burhan!

Once all services are running in the debugger, you can navigate to the web application in your browser athttp://localhost:8080And set breakpoints in any project for direct debugging.

summarize

If you're still here, keep going! I hope this guide lives up to its title and helped you get started with ASP.NET Core and Docker microservices. Finally, I want to summarize some of the key benefits these technologies and architectural styles can provide developers and organizations.

• Docker containers provide consistency across multiple development and release cycles. This helps teams save money and time by avoiding annoying deployment issues, improving DevOps, and increasing production stability.
• The modularity and lightweight of .NET Core make it ideal for developing microservices.
• Teams can run faster with microservices because they can be developed, deployed, and tested independently, unlike traditional monolithic applications.
• By significantly reducing infrastructure resources, Docker provides a better return on investment than traditional deployment models. Due to lower infrastructure requirements, Docker can essentially run the same application with fewer resources.
• Microservices can create more scalable and resilient systems. Because they typically have only one independent responsibility, they are easier to scale and replicate than monolithic services.

Thanks for reading, and if you have any questions or comments, I'd love to hear them in the comments below!

source code here