Tagged articles
Alpine
33 articles · Page 1 of 1
This guide breaks down the major Linux distributions—Debian, Ubuntu, Arch, RHEL, Fedora, Alpine, and others—explaining their package managers, stability trade‑offs, target use cases, and which one fits beginners, servers, containers, learning, or Chinese enterprise environments.
AlpineArchDebian
0 likes · 4 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 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 article evaluates various Docker base images—including Ubuntu, CentOS, Debian, Amazon Linux 2, official Python images, and Alpine—by examining stability, security updates, dependency freshness, library richness, Python version support, image size, and build time to guide developers in selecting the optimal base for Python applications.
AlpineBase ImageDocker
0 likes · 16 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 evaluates several Docker base images—Ubuntu, CentOS, Debian, Amazon Linux 2, official Python images, and Alpine—by examining stability, security updates, dependency freshness, library richness, Python version, image size, LTS support, and build time to help developers choose the optimal foundation for Python applications.
AlpineBase ImageDocker
0 likes · 17 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 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 article evaluates several Linux‑based Docker base images for Python applications, outlining stability, security, library availability, and size requirements, then compares Ubuntu, CentOS, Debian, Amazon Linux 2, official Python images and Alpine in terms of image size and build time, concluding with practical recommendations.
AlpineBase ImageBuild Time
0 likes · 17 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

To accelerate CI/CD pipelines, the article recommends using a self‑hosted GitLab Runner on a private cloud, caching build dependencies, employing lightweight Alpine images for jobs, and conditionally running tasks only when relevant files change, illustrated with a sample GitLab CI configuration.
AlpineCachingRunner
0 likes · 4 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

Learn practical Dockerfile optimization techniques—including clean build contexts, choosing minimal base images, configuring Chinese mirrors, setting time zones, consolidating RUN commands, using virtual build environments, and minimizing layers—to dramatically reduce image size and improve build efficiency.
AlpineDockerDockerfile
0 likes · 16 min read

This article evaluates popular Docker base images for Python applications—Ubuntu, CentOS, Debian, Amazon Linux 2, official Python images, and Alpine—by outlining stability, security updates, dependency freshness, library availability, Python version, image size, and build time, ultimately recommending Amazon Linux 2 and Debian/Ubuntu over Alpine.
AlpineBase ImageContainerization
0 likes · 17 min read

This article presents practical Dockerfile optimization techniques—including clean build contexts, lightweight base images, regional package mirrors, timezone configuration, virtual build environments, and layer minimization—to dramatically reduce image size and improve build efficiency.
AlpineDockerfileVirtual Build Environment
0 likes · 15 min read

This guide walks through nine incremental strategies—ranging from direct binary compilation to multi‑stage builds with Alpine and Scratch bases—to dramatically reduce the size of Go Docker images while preserving runtime performance and addressing practical trade‑offs.
AlpineScratch
0 likes · 14 min read

A detailed experiment scans several Docker base images, showing how default Python images contain hundreds of vulnerabilities, while slimmer or Alpine‑based images dramatically reduce the attack surface, highlighting the security trade‑offs of image bloat and the importance of careful base‑image selection.
AlpineDistrolessDocker
0 likes · 13 min read

This article examines why default Docker base images often contain hundreds of vulnerabilities, compares scans of Python, Alpine, and distroless images, and offers practical strategies for reducing container size and attack surface while maintaining functionality.
AlpineBest PracticesDistroless
0 likes · 13 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 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

This article explains how to shrink a Docker image for a React application from 1.16 GB to 22.4 MB by using a lightweight Alpine base, multi‑stage builds, and finally serving the compiled assets with Nginx, providing step‑by‑step Dockerfile examples and size comparisons.
AlpineContainerizationimage optimization
0 likes · 7 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

To accelerate CI/CD pipelines, the article recommends using self‑hosted GitLab Runners on a private cloud for faster network access, caching build dependencies, employing lightweight Alpine images for jobs, and limiting job execution to changed files via the only:changes rule.
AlpineCI/CDCaching
0 likes · 3 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


ITPUBDec 5, 2018 · Cloud Native
This guide presents practical Dockerizing techniques—including choosing lightweight base images, installing only necessary packages, handling file permissions, defining user privileges, exposing ports, configuring entrypoints, externalizing data, and managing logs—to help developers build secure, efficient container images.
AlpineBest PracticesDocker
0 likes · 8 min read

This article explains how to reduce Docker image size by consolidating RUN commands, using multi‑stage builds, and switching to minimal base images such as distroless or Alpine, providing concrete Node.js examples, size comparisons, and guidance on choosing the right base image for production.
AlpineDistrolesscontainer optimization
0 likes · 12 min read
