How to Reduce Docker Image Size for .NET Applications?

Introduction

When working with modern .NET applications and deploying them using Docker, one common challenge developers face is large Docker image size.

A large Docker image can lead to:

Slow build times
Increased storage usage
Slower deployments
Higher cloud costs

In simple words, a bigger image means slower and more expensive applications.

👉 That’s why optimizing and reducing Docker image size for .NET applications is very important.

In this detailed guide, you will learn practical and easy ways to reduce Docker image size in .NET Core and ASP.NET Core applications.

Why Docker Image Size Matters in .NET Applications

Faster Deployment and Startup

Smaller images download faster and start quicker in cloud environments like Azure, AWS, or Kubernetes.

👉 This improves overall performance and user experience.

Lower Infrastructure Cost

Smaller images use less bandwidth and storage.

👉 This directly reduces cloud hosting costs.

Better CI/CD Performance

In CI/CD pipelines, smaller images mean faster builds and deployments.

👉 This increases developer productivity.

Common Reasons for Large Docker Images in .NET

Using Full SDK Image in Production

Many developers use the full .NET SDK image instead of runtime image.

👉 SDK images are large because they include build tools.

Including Unnecessary Files

Files like:

Source code
Logs
Temp files
node_modules

👉 These increase image size unnecessarily.

Not Using Multi-Stage Builds

Single-stage builds include everything in one image.

👉 This makes the final image very large.

How to Reduce Docker Image Size for .NET Applications

Now let’s explore practical techniques step by step.

Use Multi-Stage Builds (Most Important)

Multi-stage builds allow you to separate build and runtime environments.

Example

# Build stage
FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /app
COPY . .
RUN dotnet publish -c Release -o out

# Runtime stage
FROM mcr.microsoft.com/dotnet/aspnet:7.0
WORKDIR /app
COPY --from=build /app/out .
ENTRYPOINT ["dotnet", "YourApp.dll"]

👉 Only the compiled output is included in the final image.

👉 This significantly reduces Docker image size.

Use Runtime Image Instead of SDK Image

Always use runtime images in production.

FROM mcr.microsoft.com/dotnet/aspnet:7.0

👉 Runtime images are smaller because they don’t include build tools.

Use Alpine-Based Images

Alpine images are lightweight Linux distributions.

FROM mcr.microsoft.com/dotnet/aspnet:7.0-alpine

👉 This can reduce image size significantly.

Note: Ensure compatibility with your application.

Use .dockerignore File

Exclude unnecessary files from Docker build context.

Example

bin/
obj/
.git/
node_modules/
*.log

👉 This prevents unwanted files from being copied into the image.

Publish Trimmed Application

You can trim unused code using .NET publish options.

dotnet publish -c Release -p:PublishTrimmed=true

👉 This removes unused assemblies and reduces size.

Use Self-Contained Deployment Carefully

Self-contained apps include runtime inside.

dotnet publish -c Release -r linux-x64 --self-contained true

👉 This increases size, so use only when necessary.

Remove Unnecessary Packages

Avoid installing extra packages in Dockerfile.

👉 Keep your image minimal and clean.

Compress and Optimize Layers

Combine commands to reduce layers.

RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

👉 Fewer layers = smaller image.

Real-World Example: Optimized Dockerfile for ASP.NET Core

# Build Stage
FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "./"]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

# Runtime Stage
FROM mcr.microsoft.com/dotnet/aspnet:7.0-alpine
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]

👉 This Dockerfile is optimized for performance and size.

Best Practices for Docker Optimization in .NET

Keep Base Images Updated

Use the latest stable .NET runtime images.

Minimize Dependencies

Only include required libraries.

Use Caching Efficiently

Order Dockerfile steps properly to leverage caching.

Monitor Image Size

Use tools like:

docker images
docker history

👉 Track and optimize regularly.

Common Mistakes to Avoid

Using SDK Image in Production

This is the most common mistake.

Ignoring .dockerignore

Leads to unnecessary file inclusion.

Not Using Multi-Stage Builds

Results in very large images.

Adding Too Many Layers

Increases image size unnecessarily.

Summary

Reducing Docker image size for .NET applications is essential for improving performance, reducing deployment time, and lowering cloud costs. By using techniques like multi-stage builds, runtime images, Alpine-based images, .dockerignore files, and optimized publish settings, you can significantly reduce your Docker image size. Following best practices and avoiding common mistakes will help you build efficient, scalable, and production-ready ASP.NET Core and .NET applications.