Tagged articles
Multi-stage Build
52 articles · Page 1 of 1
This article details Spring Boot containerization best practices: multi-stage Dockerfiles with JRE-alpine and layered jars cut image size from 800MB to ~200MB; startup probes prevent slow-start mis-kills; readiness/liveness separation avoids DB-induced restart storms; rolling updates with maxUnavailable=0, preStop sleep, and terminationGracePeriod eliminate 502 errors; CPU limits omitted to prevent GC throttling.
CDSContainerizationDocker
0 likes · 19 min read

This guide explains how to write Dockerfiles that dramatically reduce image size, speed up builds, and improve security by leveraging layer caching, multi‑stage builds, BuildKit features, proper base‑image selection, and CI/CD integration, with concrete examples for Node.js, Python, Go, and Java projects.
CI/CDContainerizationDockerfile
0 likes · 36 min read

This article explains the problems Docker solves versus virtual machines, then walks through image management, container lifecycle, data volumes, networking, Dockerfile best practices—including CMD vs ENTRYPOINT and multi‑stage builds—and Docker Compose orchestration, providing concrete commands and examples for each step.
DockerDockerfileImage
0 likes · 12 min read

This article provides a comprehensive Docker knowledge map covering core concepts, essential commands, Dockerfile instructions, multi‑stage builds, networking modes, storage options, security best practices, and a set of high‑frequency interview questions to help readers master Docker in 14 days.
DockerDocker ComposeDockerfile
0 likes · 7 min read

This article shows how to shrink Docker images and speed up builds by using multi‑stage builds, ordering instructions for layer caching, fine‑tuning .dockerignore, merging RUN commands, picking lightweight base images, and running containers as a non‑root user, with concrete code examples and build‑time measurements.
DockerMulti-stage Buildbuild-cache
0 likes · 6 min read

This guide explains how to dramatically shrink Docker image sizes by up to 70% using multi‑stage builds, Alpine or Distroless bases, layer merging, .dockerignore, and BuildKit, while also integrating Trivy security scanning, non‑root users, SUID removal, and CI/CD automation to ensure a lean, secure container deployment.
AlpineCI/CDDocker
0 likes · 29 min read

This article shares practical experience and step‑by‑step guidance on constructing minimal, secure Go service Docker images using multi‑stage builds, scratch and distroless bases, and how to handle real‑world concerns like certificates and time zones.
DistrolessDockerGo
0 likes · 7 min read

Learn how to dramatically reduce Docker build times for Spring Boot applications by using the official Jarmode=tools layered jar feature, extracting layers, and employing multi‑stage Dockerfiles with optimized runtime settings, caching strategies, and optional security and performance enhancements.
DockerJarmodeLayered Images
0 likes · 8 min read

This guide shows how to dramatically reduce Docker image sizes—from hundreds of megabytes to just a few—by selecting lightweight base images, using multi‑stage builds, optimizing layers, leveraging .dockerignore, applying BuildKit, and automating checks, with real‑world metrics demonstrating up to 90% size cuts and faster builds.
AlpineDistrolessDocker
0 likes · 13 min read

This guide explains why Docker image size matters for deployment speed, storage cost, and security, and walks through seven practical techniques—including multi‑stage builds, Alpine and Distroless bases, layer merging, dependency trimming, static compilation, and automated tools—to reduce a 1GB+ image to under 50 MB while preserving functionality.
AlpineDistrolessDocker
0 likes · 30 min read

This guide explains Dockerfile fundamentals, covering essential instructions like FROM, RUN, COPY, WORKDIR, ENV, EXPOSE, CMD, and ENTRYPOINT, shows a complete example, demonstrates multi‑stage builds to shrink images, and shares practical tips for reliable builds.
DevOpsDockerfileMulti-stage Build
0 likes · 6 min read

This article explains practical techniques for optimizing Docker images—including choosing lightweight base images, leveraging multi‑stage builds, using Docker's layer cache effectively, and consolidating RUN commands—to dramatically improve build speed, reduce image size, and enhance security.
DevOpsDockerMulti-stage Build
0 likes · 6 min read

Learn six practical techniques—including using minimal base images, multi‑stage builds, layer minimization, cache awareness, .dockerignore files, and external data storage—to dramatically reduce Docker image size, improve build speed, and lower security risks for containerized applications.
CachingDistrolessDocker
0 likes · 15 min read

This article explains why oversized Docker images hurt deployment speed, then walks through five practical strategies—including picking lightweight base images, using Distroless, applying multi‑stage builds, optimizing .dockerignore and layer ordering, and adding runtime tweaks—backed by code snippets, performance data, monitoring tips, and CI/CD integration to achieve up to 90% size reduction and dramatically faster builds.
AlpineCI/CDMulti-stage Build
0 likes · 10 min read

This article walks you through practical Docker image optimization methods—choosing lightweight base images, leveraging multi‑stage builds, trimming layers, using .dockerignore, applying BuildKit, and runtime tweaks—showing real‑world before‑and‑after results that cut image size by up to 90% and dramatically speed up builds and deployments.
AlpineDockerMulti-stage Build
0 likes · 13 min read

This article explains why Docker images bloat, then demonstrates using multi‑stage builds, Alpine base images, and Trivy vulnerability scanning—plus CI/CD integration—to produce lightweight, secure containers and streamline DevSecOps workflows.
AlpineDockerMulti-stage Build
0 likes · 7 min read

This article explains why Docker images often become bloated, outlines three hidden pitfalls of official images, and demonstrates a 75% size reduction using multi‑stage builds with Alpine, backed by real‑world performance data and practical anti‑pitfall tips.
AlpineContainerizationDevOps
0 likes · 10 min read

This article explains how Docker images are created, introduces Dockerfile syntax and key instructions such as FROM, COPY, RUN, CMD, and ENTRYPOINT, and provides practical guidelines and real‑world examples for building clean, lightweight containers.
Best PracticesContainer ImagesDocker
0 likes · 21 min read

Learn how to dramatically reduce Docker image sizes by applying six practical optimization methods—including minimal base images, multi‑stage builds, layer minimization, caching strategies, .dockerignore usage, and external data storage—while also discovering essential tools and real‑world examples to streamline your container deployments.
DevOpsDistrolessDocker
0 likes · 14 min read

Learn why smaller Docker images boost build speed and deployment efficiency, then master Docker’s multi‑stage build technique—including basic concepts, a Go example, layer reduction, cache optimization, minimal base images, non‑root users, and build arguments—to produce lightweight, secure, and maintainable containers.
DevOpsDockerGo
0 likes · 9 min read

This article explains Docker fundamentals, outlines why containers are popular, and walks through a practical example of reducing a React app's Docker image size from 1.16 GB to 22 MB using a lightweight Alpine base, multi‑stage builds, and an Nginx final stage.
AlpineContainerizationDocker
0 likes · 8 min read

By switching to a lightweight Alpine base, employing multi‑stage builds to separate compilation from runtime, and finally serving the React app with an Nginx Alpine image, Docker images can be reduced from over a gigabyte to roughly twenty‑two megabytes, enabling efficient, minimal‑footprint container deployment.
AlpineContainerizationDocker
0 likes · 6 min read

This tutorial demonstrates how to reduce Docker image size for a ReactJS project by switching to Alpine‑based Node images, applying multi‑stage builds, and finally serving the static build with Nginx, shrinking the image from over 1.4 GB to just 22 MB while preserving functionality.
ContainerizationMulti-stage BuildNode.js
0 likes · 7 min read

This article explains why a plain Dockerfile for a Spring Boot fat JAR is inefficient, introduces Spring Boot's layered JAR format, and provides a multi‑stage Dockerfile that leverages layer caching to speed up builds and reduce runtime overhead.
BackendDockerLayered JAR
0 likes · 4 min read

Learn practical techniques to accelerate Docker image builds, cut down image size, and improve security by selecting lightweight base images, applying multi‑stage builds, exploiting Docker's layer cache, and consolidating RUN commands into fewer layers.
DockerMulti-stage Buildcontainer
0 likes · 5 min read

This guide explains how to write efficient Dockerfiles by using .dockerignore, minimizing layers, combining RUN commands, selecting lightweight base images, cleaning up after installations, setting proper WORKDIR and CMD, leveraging ENTRYPOINT with exec, preferring COPY over ADD, and applying multi‑stage builds to achieve faster builds and smaller, more maintainable images.
DockerDockerfileMulti-stage Build
0 likes · 20 min read

This article explains why beginner Docker images can exceed 1 GB, then walks through multi‑stage builds, static versus dynamic linking, language‑specific tricks, and the use of minimal base images like scratch to reduce image size by over 99 % while preserving functionality.
DockerMulti-stage BuildScratch
0 likes · 16 min read

This article explains the fundamentals of Docker image layers, demonstrates how to analyze layer size with tools like docker history and dive, and provides practical optimization techniques—including multi‑stage builds, cache removal, layer squashing, and metadata‑aware copying—to dramatically reduce image footprints.
DIVEDockerDockerfile
0 likes · 11 min read

This article explains the importance of Docker for frontend development, covering its role as a consistent runtime environment, the benefits of standardized CI/CD pipelines, multi‑stage builds, caching strategies, and practical deployment patterns for static assets, Node.js services, and micro‑frontend architectures.
CI/CDContainerizationMulti-stage Build
0 likes · 22 min read

This article explains Docker fundamentals and advanced Dockerfile techniques—including using Alpine base images, multi‑stage builds, build‑time ARG variables, CMD versus ENTRYPOINT usage, and the differences between COPY and ADD—to create smaller, faster, and more flexible container images.
ARGAlpineCOPY vs ADD
0 likes · 12 min read

This guide explains why smaller Docker images improve security, transfer and deployment speed, and provides ten practical methods—including layer minimization, Docker‑squash, slim base images, multi‑stage builds, apt flags, .dockerignore, and optimization tools—to significantly reduce image size.
.dockerignoreBest PracticesDocker
0 likes · 7 min read

This article introduces Docker, explains its benefits, and walks through step‑by‑step optimizations—including using lightweight Alpine base images and multi‑stage builds—to reduce a React app’s Docker image size from over a gigabyte to just a few megabytes.
AlpineDockerMulti-stage Build
0 likes · 7 min read

This guide walks you through ten practical Docker best‑practice steps—from using deterministic image tags and minimal base images to multi‑stage builds, non‑root users, PID‑1 handling, graceful shutdown, .dockerignore usage, container‑aware JVM settings, and cautious adoption of automation tools—ensuring your Java applications run securely and efficiently in production containers.
Best PracticesContainerizationDocker
0 likes · 15 min read

This article explains Docker image fundamentals and presents four practical techniques—removing package caches, ordering layers by change frequency, separating build and runtime stages, and inspecting layers with dive—to dramatically shrink image size, speed up builds, and improve security.
Cache CleaningDockerMulti-stage Build
0 likes · 10 min read

This step‑by‑step guide shows how to create a React project, build Docker images using slimmer base images, multi‑stage builds, and Nginx, reducing the final image size from over a gigabyte to just a few megabytes while keeping the app functional.
DockerMulti-stage BuildNode.js
0 likes · 8 min read

This article explains Docker's role in modern development, distinguishes images from containers, and provides concrete security measures—including least‑privilege users, minimal base images, multi‑stage builds, and AppArmor profiles—to harden Docker deployments against attacks.
AppArmorDockerLeast Privilege
0 likes · 11 min read

This article explains Docker fundamentals and demonstrates step‑by‑step image optimizations—using Alpine base images, multi‑stage builds, and Nginx—to reduce a React app container from over a gigabyte down to just 22 MB while preserving functionality.
AlpineDockerMulti-stage Build
0 likes · 7 min read

This article explains how to dramatically shrink a Docker image for a React application—from over a gigabyte down to just 22 MB—by switching to Alpine base images, employing multi‑stage builds, and finally serving the compiled output with Nginx.
AlpineContainerizationDocker
0 likes · 6 min read

This guide explains how to dramatically reduce Docker image sizes—from over a gigabyte down to just a few megabytes—by switching to lightweight base images, employing multi‑stage builds, and using Nginx for static content, with step‑by‑step code examples and visual size comparisons.
AlpineContainerizationDocker
0 likes · 6 min read

This tutorial shows step‑by‑step how to containerize a ReactJS app and dramatically shrink its Docker image using Alpine base images, multi‑stage builds, and Nginx, reducing the size from 1.43 GB to just 22.4 MB while preserving functionality.
AlpineDockerMulti-stage Build
0 likes · 7 min read

This article explains heterogeneous Docker image builds, demonstrates how to name and reference multi‑stage build stages for clearer Dockerfiles, shows how to limit builds with the target flag for debugging, and illustrates copying files from existing images such as nginx to streamline container creation.
CI/CDDevOpsDockerfile
0 likes · 5 min read

This article explains how to optimize Docker images for a React application by switching to Alpine base images, applying multi‑stage builds, and using Nginx to serve static files, reducing the final image size from 1.16 GB to just 22 MB.
AlpineContainerizationDocker
0 likes · 6 min read

When Dockerfiles grow too large they become hard to understand, can hide security flaws, cause Git conflicts, and bloat image size, so the article presents five refactoring techniques—including using official images, extracting dependencies, multi‑stage builds, sorting parameters, and proper tagging—to keep Dockerfiles small, clear, and secure.
DockerMulti-stage Buildbest-practices
0 likes · 9 min read

This article explains why small Docker images matter, demonstrates the traditional Dockerfile approach, introduces the Builder Pattern with its drawbacks, and then shows how Docker's multi‑stage build feature can produce equally small images with far less complexity, complete with code examples.
Builder PatternContainerizationDevOps
0 likes · 8 min read

This article explains why Docker images often become oversized and presents several practical techniques—manual Dockerfile edits, multi‑stage builds, Google’s distroless images, Alpine Linux bases, and GNU Guix packaging—to dramatically reduce image size while balancing debugging convenience and security.
Alpine LinuxDistrolessDocker
0 likes · 8 min read

This article explains practical techniques for drastically reducing Docker image sizes—including Go binary static linking, Alpine vs. slim base images, multi‑stage builds for Java, Rust, and interpreted languages, and detailed size comparisons—so developers can choose the optimal base image and build strategy for any language.
AlpineDockerGo
0 likes · 20 min read

This guide explains how to create short‑lived Docker containers, manage build context efficiently, use .dockerignore, apply multi‑stage builds, avoid unnecessary packages, decouple applications, reduce image layers, sort parameters, and leverage build cache to produce lean, fast‑building images.
Multi-stage Buildbuild contextimage optimization
0 likes · 10 min read

This article explains why naïve Docker images can balloon to gigabytes, then walks through multi‑stage builds, language‑specific trimming techniques, and the use of minimal base images such as scratch, showing how to reduce image size from over a gigabyte to just a few megabytes while preserving developer and operations convenience.
DockerLinuxMulti-stage Build
0 likes · 17 min read

This article shares the 2019 cloud‑native migration experience of an e‑commerce team, covering Docker and Kubernetes basics, Java‑Docker compatibility, memory and CPU limits, log collection, JDK version choices, Dockerfile and multi‑stage build practices, health checks, graceful shutdown, and common pitfalls encountered during containerization.
ContainerizationDockerJVM
0 likes · 21 min read

This article demonstrates how to shrink Go application Docker images and accelerate CI builds by applying multi‑stage builds, consolidating RUN commands, cleaning up layers, and leveraging Docker's cache‑from feature to reuse previously built layers in GitLab CI pipelines.
AlpineCI/CDMulti-stage Build
0 likes · 12 min read

This article explains Docker containers and Dockerfiles, compares simple and compact Dockerfile examples, demonstrates single‑file versus multi‑file builds, and shows how multi‑stage builds can dramatically reduce image size while keeping Dockerfiles maintainable and efficient.
ContainerizationDevOpsDocker
0 likes · 12 min read

This article details a front‑end engineer's journey of containerizing a static‑site project with Docker and Kubernetes, addressing node_modules caching, oversized images, and complex deployment workflows, and presents three optimizations—caching dependencies, shrinking base images, and using multi‑stage builds—that cut image size to 25 MB and halve CI build time.
CI/CDDockerKubernetes
0 likes · 9 min read
