.NET Docker Container — Dockerfile Pronto para Produção

# SEM multi-estágio — envia todo o 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"]

# ── Estágio 1: restore ────────────────────────────────────────────────────────
# Etapa de restore separada para que o Docker possa fazer cache da camada até que *.csproj mude.
# Isso evita re-baixar todos os pacotes NuGet a cada mudança no código-fonte.
FROM mcr.microsoft.com/dotnet/sdk:10.0 AS restore
WORKDIR /src
 
# Copiar apenas os arquivos de projeto primeiro — esta camada é cacheada enquanto os .csproj
# não mudarem, mesmo que o restante do código-fonte mude.
COPY ["src/MyApp/MyApp.csproj", "src/MyApp/"]
COPY ["src/MyApp.Infrastructure/MyApp.Infrastructure.csproj", "src/MyApp.Infrastructure/"]
 
RUN dotnet restore "src/MyApp/MyApp.csproj"
 
# ── Estágio 2: build ──────────────────────────────────────────────────────────
FROM restore AS build
WORKDIR /src
 
# Agora copiar tudo — esta camada muda frequentemente, mas o restore já está em cache
COPY . .
 
RUN dotnet build "src/MyApp/MyApp.csproj" \
    -c Release \
    --no-restore \
    -o /app/build
 
# ── Estágio 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        # desabilitar o apphost nativo — não necessário em contêineres
 
# ── Estágio 4: imagem final de runtime ────────────────────────────────────────
FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS final
 
WORKDIR /app
 
# Copiar a saída publicada apenas do estágio de publish
# O SDK, código-fonte e artefatos de compilação nunca chegam a esta imagem
COPY --from=publish /app/publish .
 
# Informar ao ASP.NET Core para escutar na porta 8080 (não privilegiada, boa prática)
# ASPNETCORE_URLS sobrescreve os bindings padrão https/5000+5001
ENV ASPNETCORE_URLS=http://+:8080
ENV ASPNETCORE_ENVIRONMENT=Production
 
EXPOSE 8080
 
# Sem root: selecionar o usuário `app` (UID 1654) que vem em toda imagem .NET 8+.
# NÃO o crie com `RUN adduser` — a imagem Debian do .NET 10 já não inclui
# adduser/addgroup, então esse padrão clássico quebra o build (exit 127).
USER app
 
# Deliberadamente sem HEALTHCHECK: esta imagem não contém nem wget nem curl, então
# o clássico `CMD wget .../health` marca como não saudável um contêiner saudável.
# Veja a seção HEALTHCHECK abaixo para o que realmente funciona em cada imagem base.
ENTRYPOINT ["dotnet", "MyApp.dll"]

USER app

# Correto: arquivos de projeto mudam menos frequentemente do que o código-fonte
COPY ["src/MyApp/MyApp.csproj", "src/MyApp/"]
RUN dotnet restore                          # cacheado até que .csproj mude
 
COPY . .                                    # mudanças no código-fonte invalidam a partir daqui
RUN dotnet build ...

# Incorreto: copiar tudo primeiro significa que o restore é executado em cada mudança de código
COPY . .
RUN dotnet restore                          # nunca cacheado
RUN dotnet build ...

# Copiar todos os arquivos de projeto, preservando a estrutura de diretórios
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

# Somente Alpine: o BusyBox traz wget embutido
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 o endpoint de health — mantê-lo leve, sem autenticação necessária
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 (o processo está vivo?) de readiness (pode servir tráfego?)
app.MapHealthChecks("/health/live", new HealthCheckOptions
{
    Predicate = _ => false   // apenas a verificação base, sem dependências
});
 
app.MapHealthChecks("/health/ready", new HealthCheckOptions
{
    Predicate = check => check.Tags.Contains("database")
});

# Padrões de variáveis de ambiente no Dockerfile (podem ser sobrescritos em tempo de execução)
ENV ASPNETCORE_ENVIRONMENT=Production
ENV ASPNETCORE_URLS=http://+:8080
 
# NÃO inclua connection strings ou segredos na imagem.
# Passe-os em tempo de execução via -e ou seção environment do 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 uma plataforma específica
docker build --platform linux/amd64 -t myapp:latest .
 
# Construir e publicar um manifesto multi-arch (requer 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
      # Passar 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 — usado apenas localmente, não no CI
version: "3.9"
 
services:
  app:
    # Montar código-fonte para hot reload no desenvolvimento
    volumes:
      - .:/src
    environment:
      # Habilitar erros detalhados
      ASPNETCORE_ENVIRONMENT: Development
      # Desabilitar redirecionamento HTTPS no Docker local
      ASPNETCORE_HTTPS_PORT: ""

# Analisar a imagem local
docker scout cves myapp:latest
 
# Mostrar apenas vulnerabilidades de severidade crítica e alta
docker scout cves --only-severity critical,high myapp:latest
 
# Comparar duas versões de imagem
docker scout compare myapp:latest myapp:previous
 
# Obter um resumo rápido
docker scout quickview myapp:latest

# Passo do GitHub Actions
- name: Varrer imagem em 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 o runtime para evitar problemas de dependência 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
 
# O mesmo usuário sem root embutido de toda imagem .NET 8+
USER app
 
# Isto funciona especificamente no Alpine — o BusyBox fornece wget
HEALTHCHECK --interval=30s --timeout=5s --start-period=15s --retries=3 \
    CMD wget -qO- http://localhost:8080/health || exit 1
 
ENTRYPOINT ["dotnet", "MyApp.dll"]