0 views collected around this technical thread.
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.
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.
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.
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.
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.
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.
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.
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.
This article explains how to reduce Docker image size by switching to Alpine base images, applying multi‑stage builds, and finally serving the built React application with Nginx, shrinking an initial 1.16 GB image down to just 22.4 MB.
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.
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.
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.
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.
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.
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.
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.