Environment Detection in DotNetCore Docker Apps: A Complete Guide (2026)

When developing applications using DotNetCore, determining the environment in which your console app is running can be crucial. This allows you to load the appropriate configuration files, such as appsettings.Development.json or appsettings.Production.json. Running your application in a Docker container adds another layer of complexity, as the environment needs to be set up correctly within the container.

Key Takeaways

• Understand how to detect the environment within a DotNetCore application running in Docker.
• Learn how to set environment variables in Docker to control your app's behavior.
• Explore best practices for managing multiple environment configurations.
• Get familiar with common pitfalls and troubleshooting techniques.

In this tutorial, we will cover how to determine the environment in which a DotNetCore console application is running when deployed inside a Docker container. This knowledge is vital for ensuring that your application loads the correct configuration settings, which can significantly affect its behavior and performance.

Prerequisites

• Basic understanding of Docker and how to create and run Docker containers.
• Familiarity with DotNetCore applications and configuration management.
• DotNetCore SDK 6.0 or later and Docker installed on your development machine.

Step 1: Configure Your DotNetCore Application

First, ensure your DotNetCore application is set up to read environment-specific configuration files. This is typically done via the appsettings.json file and its environment-specific counterparts.

var environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production";
Console.WriteLine($"Environment: {environmentName}");

var builder = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
    .AddJsonFile($"appsettings.{environmentName}.json", optional: true)
    .AddEnvironmentVariables();
var configuration = builder.Build();

This code snippet checks for the ASPNETCORE_ENVIRONMENT variable and loads the appropriate configuration file. By default, it falls back to "Production" if no environment is specified.

Step 2: Set Up Dockerfile

Next, we need to ensure that our Docker container is set up to define the necessary environment variables. Here's a basic Dockerfile for a DotNetCore application:

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["YourApp/YourApp.csproj", "./"]
RUN dotnet restore "./YourApp.csproj"
COPY . .
WORKDIR "/src/YourApp"
RUN dotnet build "YourApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "YourApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "YourApp.dll"]

To specify an environment variable, you can use the ENV instruction in your Dockerfile:

ENV ASPNETCORE_ENVIRONMENT=Development

This will ensure that the ASPNETCORE_ENVIRONMENT variable is set within your Docker container, allowing your application to load the appropriate configuration file.

Step 3: Running the Docker Container

Once your Dockerfile is configured, build your Docker image and run the container. Use the following commands:

docker build -t yourapp:latest .
docker run -d -p 8080:80 --name yourapp --env ASPNETCORE_ENVIRONMENT=Development yourapp:latest

The --env flag allows you to override the environment variable at runtime, providing flexibility for different deployment scenarios.

Step 4: Verify Environment Detection

With the container running, you can log the environment to verify it's correctly set:

Console.WriteLine($"Running in environment: {environmentName}");

Check the logs of your running container to see the output:

docker logs yourapp

You should see the line indicating which environment the application is running in, confirming the correct environment variable is being used.

Common Errors/Troubleshooting

• Environment Variable Not Set: Ensure you set the ASPNETCORE_ENVIRONMENT variable in your Dockerfile or when running the container.
• Configuration File Not Found: Check that your configuration files are in the expected directory and named correctly.
• Docker Image Not Rebuilding: Use docker build --no-cache to ensure changes are applied.

Conclusion

By following these steps, you can effectively manage and detect environments for DotNetCore console applications running in Docker containers. This setup allows for scalable and flexible application deployment across different environments, ensuring that the correct configurations are always applied.

Frequently Asked Questions

Why is it important to detect the environment in a Dockerized DotNetCore app?

Detecting the environment allows your application to load the correct configuration, ensuring it behaves appropriately for development, testing, or production environments.

How can I verify the environment in my DotNetCore application?

You can log the environment variable using Console.WriteLine and check the container logs to verify it's set correctly.

What if my environment variable isn't being detected?

Ensure the variable is set in the Dockerfile or passed at runtime using the --env flag. Also, check for typos and correct Docker image rebuilding.