Docker & Containerization

# Dockerfile HEALTHCHECK (used by plain Docker/Swarm, often redundant in Kubernetes)
HEALTHCHECK --interval=30s --timeout=3s CMD curl -f http://localhost:8080/health || exit 1

# Kubernetes equivalent, configured in the Pod spec instead:
livenessProbe:
  httpGet: { path: /health/live, port: 8080 }
  periodSeconds: 10

Common follow-ups: Why can't Kubernetes just use the Dockerfile HEALTHCHECK directly?;What's the difference between liveness and readiness probes in terms of orchestrator behavior?

# .dockerignore
bin/
obj/
.git/
.vs/
*.user
**/node_modules

# Without this, COPY . . would include local bin/obj folders,
# potentially conflicting with the container's own build output

Common follow-ups: What happens specifically if local bin/obj artifacts leak into the image via COPY?;How does .dockerignore syntax compare to .gitignore syntax?

# Copy project files first, preserving directory structure for references
COPY *.sln .
COPY src/MyApi/*.csproj src/MyApi/
COPY src/MyLib/*.csproj src/MyLib/
RUN dotnet restore

# THEN copy all source code (invalidates cache more often, but restore stays cached)
COPY . .
RUN dotnet publish -c Release -o /app/publish

Common follow-ups: How does this pattern scale as the number of projects grows very large?;What's the trade-off of this more complex Dockerfile versus simplicity?

docker build -t myapp:1.0 .          # builds an image
docker run -d --name instance1 myapp:1.0  # runs a container from that image
docker run -d --name instance2 myapp:1.0  # runs ANOTHER independent container from the SAME image

Common follow-ups: What happens to data written inside a container when it stops or is removed?;How do you persist data across container restarts using volumes?

# In the Dockerfile or docker run command
ENV ASPNETCORE_URLS=http://+:8080
EXPOSE 8080

# Running with port mapping: host port 5000 -> container port 8080
docker run -p 5000:8080 myapp:latest

Common follow-ups: What's the difference between EXPOSE in a Dockerfile and the -p flag at runtime?;Why must a containerized app bind to 0.0.0.0 or + rather than localhost?

[ApiController]
[Route("api/products")]
public class ProductsController : ControllerBase {
    [HttpGet]
    public IEnumerable<string> Get() => new[] { "Product1", "Product2" };
}
// Each microservice like this is packaged into its own Docker image and
// deployed/scaled independently behind Kubernetes

Common follow-ups: What specific new failure modes (network partitions, partial failures) does a microservices architecture introduce that a monolith doesn't have?;How does .NET Aspire reduce the setup overhead traditionally associated with running microservices locally during development?