Use containers for .NET development
Prerequisites
Complete Containerize a .NET application.
Overview
In this section, you'll learn how to set up a development environment for your containerized application. This includes:
- Adding a local database and persisting data
- Configuring Compose to automatically update your running Compose services as you edit and save your code
- Creating a development container that contains the .NET Core SDK tools and dependencies
Update the application
This section uses a different branch of the docker-dotnet-sample
repository
that contains an updated .NET application. The updated application is on the
add-db
branch of the repository you cloned in
Containerize a .NET
application.
To get the updated code, you need to checkout the add-db
branch. For the changes you made in
Containerize a .NET application, for this section, you can stash them. In a terminal, run the following commands in the docker-dotnet-sample
directory.
Stash any previous changes.
$ git stash -u
Check out the new branch with the updated application.
$ git checkout add-db
In the add-db
branch, only the .NET application has been updated. None of the Docker assets have been updated yet.
You should now have the following in your docker-dotnet-sample
directory.
├── docker-dotnet-sample/
│ ├── .git/
│ ├── src/
│ │ ├── Data/
│ │ ├── Models/
│ │ ├── Pages/
│ │ ├── Properties/
│ │ ├── wwwroot/
│ │ ├── appsettings.Development.json
│ │ ├── appsettings.json
│ │ ├── myWebApp.csproj
│ │ └── Program.cs
│ ├── tests/
│ │ ├── tests.csproj
│ │ ├── UnitTest1.cs
│ │ └── Usings.cs
│ ├── .dockerignore
│ ├── .gitignore
│ ├── compose.yaml
│ ├── Dockerfile
│ ├── README.Docker.md
│ └── README.md
Add a local database and persist data
You can use containers to set up local services, like a database. In this section, you'll update the compose.yaml
file to define a database service and a volume to persist data.
Open the compose.yaml
file in an IDE or text editor. You'll notice it
already contains commented-out instructions for a PostgreSQL database and volume.
Open docker-dotnet-sample/src/appsettings.json
in an IDE or text editor. You'll
notice the connection string with all the database information. The
compose.yaml
already contains this information, but it's commented out.
Uncomment the database instructions in the compose.yaml
file.
The following is the updated compose.yaml
file.
services:
server:
build:
context: .
target: final
ports:
- 8080:80
depends_on:
db:
condition: service_healthy
db:
image: postgres
restart: always
user: postgres
secrets:
- db-password
volumes:
- db-data:/var/lib/postgresql/data
environment:
- POSTGRES_DB=example
- POSTGRES_PASSWORD_FILE=/run/secrets/db-password
expose:
- 5432
healthcheck:
test: ["CMD", "pg_isready"]
interval: 10s
timeout: 5s
retries: 5
volumes:
db-data:
secrets:
db-password:
file: db/password.txt
Note
To learn more about the instructions in the Compose file, see Compose file reference.
Before you run the application using Compose, notice that this Compose file uses
secrets
and specifies a password.txt
file to hold the database's password.
You must create this file as it's not included in the source repository.
In the docker-dotnet-sample
directory, create a new directory named db
and
inside that directory create a file named password.txt
. Open password.txt
in an IDE or text editor and add the following password. The password must be on a single line, with no additional lines in the file.
example
Save and close the password.txt
file.
You should now have the following in your docker-dotnet-sample
directory.
├── docker-dotnet-sample/
│ ├── .git/
│ ├── db/
│ │ └── password.txt
│ ├── src/
│ ├── tests/
│ ├── .dockerignore
│ ├── .gitignore
│ ├── compose.yaml
│ ├── Dockerfile
│ ├── README.Docker.md
│ └── README.md
Run the following command to start your application.
$ docker compose up --build
Open a browser and view the application at
http://localhost:8080. You should see a simple web application with the text Student name is
.
The application doesn't display a name because the database is empty. For this application, you need to access the database and then add records.
Add records to the database
For the sample application, you must access the database directly to create sample records.
You can run commands inside the database container using the docker exec
command. Before running that command, you must get the ID of the database
container. Open a new terminal window and run the following command to list all
your running containers.
$ docker container ls
You should see output like the following.
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cb36e310aa7e docker-dotnet-server "dotnet myWebApp.dll" About a minute ago Up About a minute 0.0.0.0:8080->80/tcp docker-dotnet-server-1
39fdcf0aff7b postgres "docker-entrypoint.s…" About a minute ago Up About a minute (healthy) 5432/tcp docker-dotnet-db-1
In the previous example, the container ID is 39fdcf0aff7b
. Run the following command to connect to the postgres database in the container. Replace the container ID with your own container ID.
$ docker exec -it 39fdcf0aff7b psql -d example -U postgres
And finally, insert a record into the database.
example=# INSERT INTO "Students" ("ID", "LastName", "FirstMidName", "EnrollmentDate") VALUES (DEFAULT, 'Whale', 'Moby', '2013-03-20');
You should see output like the following.
INSERT 0 1
Close the database connection and exit the container shell by running exit
.
example=# exit
Verify that data persists in the database
Open a browser and view the application at
http://localhost:8080. You should see a simple web application with the text Student name is Whale Moby
.
Press ctrl+c
in the terminal to stop your application.
In the terminal, run docker compose rm
to remove your containers and then run docker compose up
to run your application again.
$ docker compose rm
$ docker compose up --build
Refresh http://localhost:8080 in your browser and verify that the student name persisted, even after the containers were removed and ran again.
Press ctrl+c
in the terminal to stop your application.
Automatically update services
Use Compose Watch to automatically update your running Compose services as you edit and save your code. For more details about Compose Watch, see Use Compose Watch.
Open your compose.yaml
file in an IDE or text editor and then add the Compose Watch instructions. The following is the updated compose.yaml
file.
services:
server:
build:
context: .
target: final
ports:
- 8080:80
depends_on:
db:
condition: service_healthy
develop:
watch:
- action: rebuild
path: .
db:
image: postgres
restart: always
user: postgres
secrets:
- db-password
volumes:
- db-data:/var/lib/postgresql/data
environment:
- POSTGRES_DB=example
- POSTGRES_PASSWORD_FILE=/run/secrets/db-password
expose:
- 5432
healthcheck:
test: ["CMD", "pg_isready"]
interval: 10s
timeout: 5s
retries: 5
volumes:
db-data:
secrets:
db-password:
file: db/password.txt
Run the following command to run your application with Compose Watch.
$ docker compose watch
Open a browser and verify that the application is running at http://localhost:8080.
Any changes to the application's source files on your local machine will now be immediately reflected in the running container.
Open docker-dotnet-sample/src/Pages/Index.cshtml
in an IDE or text editor and update the student name text on line 13 from Student name is
to Student name:
.
- <p>Student Name is @Model.StudentName</p>
+ <p>Student name: @Model.StudentName</p>
Save the changes to Index.cshmtl
and then wait a few seconds for the application to rebuild. Refresh
http://localhost:8080 in your browser and verify that the updated text appears.
Press ctrl+c
in the terminal to stop your application.
Create a development container
At this point, when you run your containerized application, it's using the .NET runtime image. While this small image is good for production, it lacks the SDK tools and dependencies you may need when developing. Also, during development, you may not need to run dotnet publish
. You can use multi-stage builds to build stages for both development and production in the same Dockerfile. For more details, see
Multi-stage builds.
Add a new development stage to your Dockerfile and update your compose.yaml
file to use this stage for local development.
The following is the updated Dockerfile.
# syntax=docker/dockerfile:1
FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
ARG TARGETARCH
COPY . /source
WORKDIR /source/src
RUN --mount=type=cache,id=nuget,target=/root/.nuget/packages \
dotnet publish -a ${TARGETARCH/amd64/x64} --use-current-runtime --self-contained false -o /app
FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS development
COPY . /source
WORKDIR /source/src
CMD dotnet run --no-launch-profile
FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine AS final
WORKDIR /app
COPY --from=build /app .
ARG UID=10001
RUN adduser \
--disabled-password \
--gecos "" \
--home "/nonexistent" \
--shell "/sbin/nologin" \
--no-create-home \
--uid "${UID}" \
appuser
USER appuser
ENTRYPOINT ["dotnet", "myWebApp.dll"]
The following is the updated compose.yaml
file.
services:
server:
build:
context: .
target: development
ports:
- 8080:80
depends_on:
db:
condition: service_healthy
develop:
watch:
- action: rebuild
path: .
environment:
- ASPNETCORE_ENVIRONMENT=Development
- ASPNETCORE_URLS=http://+:80'
db:
image: postgres
restart: always
user: postgres
secrets:
- db-password
volumes:
- db-data:/var/lib/postgresql/data
environment:
- POSTGRES_DB=example
- POSTGRES_PASSWORD_FILE=/run/secrets/db-password
expose:
- 5432
healthcheck:
test: ["CMD", "pg_isready"]
interval: 10s
timeout: 5s
retries: 5
volumes:
db-data:
secrets:
db-password:
file: db/password.txt
Your containerized application will now use the mcr.microsoft.com/dotnet/sdk:6.0-alpine
image, which includes development tools like dotnet test
. Continue to the next section to learn how you can run dotnet test
.
Summary
In this section, you took a look at setting up your Compose file to add a local database and persist data. You also learned how to use Compose Watch to automatically rebuild and run your container when you update your code. And finally, you learned how to create a development container that contains the SDK tools and dependencies needed for development.
Related information:
Next steps
In the next section, you'll learn how to run unit tests using Docker.