.NET Docker Container — Dockerfile Listo para Producción

# SIN multi-etapa — envía todo el SDK (846 MB)
FROM mcr.microsoft.com/dotnet/sdk:10.0
WORKDIR /app
COPY . .
RUN dotnet publish -c Release -o out
ENTRYPOINT ["dotnet", "out/MyApp.dll"]

# ── Etapa 1: restore ──────────────────────────────────────────────────────────
# Paso de restore separado para que Docker pueda cachear la capa hasta que cambien *.csproj.
# Esto evita re-descargar todos los paquetes NuGet en cada cambio de código fuente.
FROM mcr.microsoft.com/dotnet/sdk:10.0 AS restore
WORKDIR /src
 
# Copiar solo los archivos de proyecto primero — esta capa se cachea mientras los .csproj
# no cambien, incluso si el resto del código fuente cambia.
COPY ["src/MyApp/MyApp.csproj", "src/MyApp/"]
COPY ["src/MyApp.Infrastructure/MyApp.Infrastructure.csproj", "src/MyApp.Infrastructure/"]
 
RUN dotnet restore "src/MyApp/MyApp.csproj"
 
# ── Etapa 2: build ────────────────────────────────────────────────────────────
FROM restore AS build
WORKDIR /src
 
# Ahora copiar todo — esta capa cambia frecuentemente, pero restore ya está cacheado
COPY . .
 
RUN dotnet build "src/MyApp/MyApp.csproj" \
    -c Release \
    --no-restore \
    -o /app/build
 
# ── Etapa 3: publish ──────────────────────────────────────────────────────────
FROM build AS publish
RUN dotnet publish "src/MyApp/MyApp.csproj" \
    -c Release \
    --no-restore \
    --no-build \
    -o /app/publish \
    /p:UseAppHost=false        # deshabilitar el apphost nativo — no es necesario en contenedores
 
# ── Etapa 4: imagen final de runtime ──────────────────────────────────────────
FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS final
 
WORKDIR /app
 
# Copiar la salida publicada solo desde la etapa de publish
# El SDK, el código fuente y los artefactos de compilación nunca llegan a esta imagen
COPY --from=publish /app/publish .
 
# Indicarle a ASP.NET Core que escuche en el puerto 8080 (no privilegiado, buena práctica)
# ASPNETCORE_URLS sobreescribe los bindings predeterminados https/5000+5001
ENV ASPNETCORE_URLS=http://+:8080
ENV ASPNETCORE_ENVIRONMENT=Production
 
EXPOSE 8080
 
# Sin root: seleccionar el usuario `app` (UID 1654) que trae toda imagen .NET 8+.
# NO lo crees con `RUN adduser` — la imagen Debian de .NET 10 ya no incluye
# adduser/addgroup, así que ese patrón clásico rompe el build (exit 127).
USER app
 
# Deliberadamente sin HEALTHCHECK: esta imagen no contiene ni wget ni curl, así que
# el clásico `CMD wget .../health` marca como no saludable un contenedor sano.
# Consulta la sección HEALTHCHECK más abajo para ver qué funciona en cada imagen base.
ENTRYPOINT ["dotnet", "MyApp.dll"]

USER app

# Bien: los archivos de proyecto cambian con menos frecuencia que el código fuente
COPY ["src/MyApp/MyApp.csproj", "src/MyApp/"]
RUN dotnet restore                          # cacheado hasta que cambie .csproj
 
COPY . .                                    # los cambios de código fuente invalidan desde aquí
RUN dotnet build ...

# Mal: copiar todo primero significa que restore se ejecuta en cada cambio de código
COPY . .
RUN dotnet restore                          # nunca cacheado
RUN dotnet build ...

# Copiar todos los archivos de proyecto, preservando la estructura de directorios
COPY ["Directory.Build.props", "."]
COPY ["src/MyApp/MyApp.csproj", "src/MyApp/"]
COPY ["src/MyApp.Infrastructure/MyApp.Infrastructure.csproj", "src/MyApp.Infrastructure/"]
COPY ["src/MyApp.Contracts/MyApp.Contracts.csproj", "src/MyApp.Contracts/"]
RUN dotnet restore "src/MyApp/MyApp.csproj"

# .dockerignore
**/.git
**/.gitignore
**/.vs
**/.vscode
**/bin
**/obj
**/out
**/*.user
**/*.md
**/tests
**/TestResults
Dockerfile*
docker-compose*
.dockerignore
README.md

# Solo Alpine: BusyBox trae wget incorporado
HEALTHCHECK --interval=30s --timeout=5s --start-period=15s --retries=3 \
    CMD wget -qO- http://localhost:8080/health || exit 1

// Program.cs
builder.Services.AddHealthChecks();
 
// Mapear el endpoint de health — mantenerlo ligero, sin autenticación requerida
app.MapHealthChecks("/health");

builder.Services.AddHealthChecks()
    .AddSqlServer(
        connectionString: builder.Configuration.GetConnectionString("DefaultConnection")!,
        name: "sql-server",
        tags: ["database", "sql"])
    .AddRedis(
        redisConnectionString: builder.Configuration.GetConnectionString("Redis")!,
        name: "redis",
        tags: ["cache"]);
 
// Separar liveness (¿está vivo el proceso?) de readiness (¿puede servir tráfico?)
app.MapHealthChecks("/health/live", new HealthCheckOptions
{
    Predicate = _ => false   // solo la verificación base, sin dependencias
});
 
app.MapHealthChecks("/health/ready", new HealthCheckOptions
{
    Predicate = check => check.Tags.Contains("database")
});

# Variables de entorno predeterminadas en Dockerfile (pueden sobreescribirse en tiempo de ejecución)
ENV ASPNETCORE_ENVIRONMENT=Production
ENV ASPNETCORE_URLS=http://+:8080
 
# NO incluir connection strings ni secretos en la imagen.
# Pasarlos en tiempo de ejecución mediante -e o la sección environment de docker-compose.

docker run -p 8080:8080 \
  -e ConnectionStrings__DefaultConnection="Server=db;Database=myapp;..." \
  -e ASPNETCORE_ENVIRONMENT=Staging \
  myapp:latest

ARG BUILD_VERSION=1.0.0
ARG GIT_COMMIT=unknown
 
LABEL org.opencontainers.image.version="${BUILD_VERSION}"
LABEL org.opencontainers.image.revision="${GIT_COMMIT}"
LABEL org.opencontainers.image.source="https://github.com/myorg/myapp"

docker build \
  --build-arg BUILD_VERSION=2.1.0 \
  --build-arg GIT_COMMIT=$(git rev-parse --short HEAD) \
  -t myapp:2.1.0 .

# Construir para una plataforma específica
docker build --platform linux/amd64 -t myapp:latest .
 
# Construir y publicar un manifiesto multi-arch (requiere buildx)
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t myregistry.azurecr.io/myapp:latest \
  --push \
  .

# docker-compose.yml
version: "3.9"
 
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
      # Pasar argumentos de build
      args:
        BUILD_VERSION: "dev"
    ports:
      - "8080:8080"
    environment:
      ASPNETCORE_ENVIRONMENT: Development
      ASPNETCORE_URLS: http://+:8080
      ConnectionStrings__DefaultConnection: >-
        Server=sqlserver;Database=MyApp;
        User Id=sa;Password=YourStrong!Passw0rd;
        TrustServerCertificate=True
      ConnectionStrings__Redis: redis:6379
    depends_on:
      sqlserver:
        condition: service_healthy
      redis:
        condition: service_started
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:8080/health"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 20s
 
  sqlserver:
    image: mcr.microsoft.com/mssql/server:2022-latest
    environment:
      SA_PASSWORD: "YourStrong!Passw0rd"
      ACCEPT_EULA: "Y"
    ports:
      - "1433:1433"
    volumes:
      - sqldata:/var/opt/mssql
    healthcheck:
      test: ["CMD", "/opt/mssql-tools/bin/sqlcmd",
             "-S", "localhost", "-U", "sa",
             "-P", "YourStrong!Passw0rd", "-Q", "SELECT 1"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
 
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
 
volumes:
  sqldata:

  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: myapp
      POSTGRES_PASSWORD: mypassword
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U myapp"]
      interval: 10s
      timeout: 5s
      retries: 5
 
volumes:
  pgdata:

    environment:
      ConnectionStrings__DefaultConnection: >-
        Host=postgres;Database=myapp;
        Username=myapp;Password=mypassword

# docker-compose.override.yml — solo usado localmente, no en CI
version: "3.9"
 
services:
  app:
    # Montar código fuente para hot reload en desarrollo
    volumes:
      - .:/src
    environment:
      # Habilitar errores detallados
      ASPNETCORE_ENVIRONMENT: Development
      # Deshabilitar redirección HTTPS en Docker local
      ASPNETCORE_HTTPS_PORT: ""

# Analizar la imagen local
docker scout cves myapp:latest
 
# Mostrar solo vulnerabilidades de severidad crítica y alta
docker scout cves --only-severity critical,high myapp:latest
 
# Comparar dos versiones de imagen
docker scout compare myapp:latest myapp:previous
 
# Obtener un resumen rápido
docker scout quickview myapp:latest

# Paso de GitHub Actions
- name: Escanear imagen en busca de vulnerabilidades
  run: |
    docker scout cves \
      --only-severity critical,high \
      --exit-code \
      myapp:${{ github.sha }}

FROM mcr.microsoft.com/dotnet/sdk:10.0-alpine AS restore
WORKDIR /src
COPY ["src/MyApp/MyApp.csproj", "src/MyApp/"]
RUN dotnet restore "src/MyApp/MyApp.csproj" \
    --runtime linux-musl-x64           # RID musl para Alpine
 
FROM restore AS build
WORKDIR /src
COPY . .
RUN dotnet build "src/MyApp/MyApp.csproj" \
    -c Release \
    --no-restore \
    -o /app/build
 
FROM build AS publish
RUN dotnet publish "src/MyApp/MyApp.csproj" \
    -c Release \
    --no-restore \
    --no-build \
    --runtime linux-musl-x64 \
    --self-contained true \             # incluir el runtime para evitar problemas de dependencia musl
    /p:UseAppHost=false \
    -o /app/publish
 
FROM mcr.microsoft.com/dotnet/aspnet:10.0-alpine AS final
 
WORKDIR /app
COPY --from=publish /app/publish .
 
ENV ASPNETCORE_URLS=http://+:8080
EXPOSE 8080
 
# El mismo usuario sin root incorporado que en toda imagen .NET 8+
USER app
 
# Esto funciona específicamente en Alpine — BusyBox proporciona wget
HEALTHCHECK --interval=30s --timeout=5s --start-period=15s --retries=3 \
    CMD wget -qO- http://localhost:8080/health || exit 1
 
ENTRYPOINT ["dotnet", "MyApp.dll"]