Container security in production requires a defense-in-depth approach. Default container configurations often run as root, include unnecessary package managers (like apt or apk), and retain development toolchains within the final runtime artifact. These patterns dramatically expand the container attack surface and increase vulnerability exposure.
Securing containers requires implementing three foundational principles: isolating build dependencies, running as a non-privileged user, and stripping away unnecessary operating system utilities.
1. The Three Pillars of Container Hardening
- Multi-Stage Builds: Separates the compilation environment from the final deployment container. Build tools, source code, and intermediate caches are discarded, leaving only the compiled binary or runtime bytecode.
- Rootless / Non-Root Execution: Restricts the container process to an unprivileged UID/GID (e.g., UID 10001). This prevents attackers from easily escalating privileges on the underlying host kernel in the event of a container escape.
- Distroless Base Images: Uses minimalist base images (such as
gcr.io/distroless) that contain only your application and its direct runtime dependencies—completely excluding shell binaries (/bin/sh,/bin/bash), package managers, and standard Linux utilities.
2. Production Multi-Stage Dockerfile Walkthrough
Below is a hardened Dockerfile for a production microservice:
# Stage 1: Build & Compilation
FROM golang:1.22-alpine AS builder
WORKDIR /src
# Download dependencies separately to leverage Docker layer caching
COPY go.mod go.sum ./
RUN go mod download
COPY . .
# Build a statically linked, stripped binary
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
-ldflags="-w -s" \
-o /bin/server ./cmd/server
# Stage 2: Hardened Runtime Container
FROM gcr.io/distroless/static-debian12:nonroot
WORKDIR /app
# Copy the compiled binary from the builder stage
COPY --from=builder /bin/server /app/server
# Run as the default nonroot user (UID 65532)
USER nonroot:nonroot
EXPOSE 8080
ENTRYPOINT ["/app/server"]
3. Hardening the Container at the Orchestration Layer
Complement Docker image hardening with strict Kubernetes Pod Security Standards using a restrictive securityContext:
apiVersion: apps/v1
kind: Deployment
metadata:
name: secure-service
spec:
replicas: 3
template:
spec:
securityContext:
runAsNonRoot: true
runAsUser: 65532
runAsGroup: 65532
fsGroup: 65532
containers:
- name: secure-service
image: registry.example.com/secure-service:v1.0.0
securityContext:
allowPrivilegeEscalation: false
readOnlyRootFilesystem: true
capabilities:
drop:
- ALL
resources:
limits:
cpu: 500m
memory: 256Mi
requests:
cpu: 100m
memory: 128Mi
Key Implementation Takeaways
- Discard Build Artifacts: Always use multi-stage builds to prevent build toolchains and package caches from reaching production images.
- Enforce nonroot by Default: Explicitly set
USER nonrootin the Dockerfile and enforcerunAsNonRoot: truein your container runtime or Kubernetes manifest. - Strip Shells and Utilities: Deploy onto distroless or scratch images to neutralize interactive shell injection and living-off-the-land attacks.
- Make Root Filesystems Read-Only: Pair
readOnlyRootFilesystem: truewith explicitemptyDirtemporary volumes for writable directories (/tmp).
No comments:
Post a Comment