This article traces the evolution of operating‑system level virtualization from the early UNIX chroot to modern Docker containers, explaining the roles of chroot, control groups, various Linux namespaces, their implementation details, and how Docker leverages these mechanisms for isolation and resource management.
This article explains what Podman is, highlights its key differences from Docker—including daemon‑less operation and rootless security—covers installation, configuration, common commands for managing containers, images, volumes, and networking, and provides practical examples for using Podman as a Docker‑compatible, cloud‑native container runtime.
This article provides a comprehensive overview of Linux cgroups, explaining their purpose, architecture, versions, subsystems, and practical usage with systemd, including installation, configuration files, command‑line tools, and methods to monitor and limit CPU, memory, and I/O resources for containers and services.
This article explains how Go's efficient concurrency model, lightweight runtime, and rich standard library make it ideal for building scalable cloud computing solutions and microservice architectures, while also providing code examples for coroutines, HTTP services, and container integration.
The New Relic 2023 Java Ecosystem Report analyzes production usage data to reveal rapid adoption of Java 17, declining popularity of older LTS releases, the rise of containerized applications, and Amazon Corretto becoming the leading JDK vendor, while highlighting preferred garbage collectors and non‑LTS usage patterns.
The 2023 New Relic Java ecosystem report reveals that Java 17 usage jumped over 430% in a single year, Java 11 remains dominant, Amazon Corretto now leads JDK market share, containerized deployments hit 70%, and the G1 garbage collector stays the top choice among Java 11+ users.
The 2022‑2023 CNBPA cloud‑native survey of 294 financial institutions reveals that hybrid multi‑cloud deployments, FinOps cost‑management, platform‑engineered DevOps, and increasing adoption of containers, micro‑services, and bare‑metal servers are driving a rapid shift toward cloud‑native architectures across banks, insurers, securities firms and other financial entities.
This article explains Linux cgroups, why they are essential for containerization, their architecture, subsystems, and practical commands for viewing, configuring, and limiting CPU, memory, and I/O resources using systemd and the cgroup filesystem.
This article explains Docker’s lightweight container engine, its goals, core concepts such as images, containers, and repositories, compares containers to virtual machines, introduces Dockerfile, cgroups, Docker Compose, Docker Machine, and provides an overview of Kubernetes architecture and components, highlighting their role in cloud‑native environments.
This article introduces Kubernetes fundamentals through a series of questions and answers, covering its architecture, node communication, pod scheduling, data storage, external access, scaling mechanisms, and component coordination, all illustrated with clear diagrams.
This article provides a concise, question‑driven overview of Kubernetes, covering its architecture, node and master communication, pod fundamentals, scheduling, storage via etcd, service exposure, scaling mechanisms, and the roles of core components such as kube‑apiserver, kubelet, kube‑proxy and controllers.
This article walks through the complete lifecycle of a Kubernetes deployment, explaining how a manual upgrade request triggers API calls, creates Deployments, ReplicaSets, Pods, and how the scheduler, kubelet, and Docker work together, while also covering concepts like containers, labels, replication controllers, deployments, and autoscaling mechanisms.
This article explains how the ParallelGCThreads JVM flag defaults differ across JDK versions, why older JDKs report excessive GC threads inside limited‑CPU containers, and how to verify and retrieve accurate container resource limits using cgroup files and updated JDK releases.
Virtual machines are software‑emulated computers that isolate operating systems and applications from physical hardware, enabling server consolidation, resource sharing, and the foundation for modern cloud, edge, and 5G technologies, while offering benefits like cost savings, testing environments, and security isolation despite some performance trade‑offs.
Linux cgroups, a kernel mechanism for grouping and controlling processes, enable fine-grained resource allocation, monitoring, and isolation, forming the foundation of container technologies like Docker and Kubernetes; this guide explains their concepts, hierarchies, subsystems, versions, configuration, and practical usage on CentOS.
This article provides a comprehensive overview of virtual machines, explaining their definition, history, types of hypervisors, advantages and disadvantages, and how they underpin modern cloud computing, edge computing, 5G, and container technologies.
Docker containers run from images composed of stacked read‑only layers topped by a writable layer, enabling isolated processes and efficient storage, while commands such as create, run, commit, build, and prune manage lifecycle, and Dockerfiles generate new layers for versioned, portable deployments.
A whimsical tale explains how Docker solves application deployment pain by using chroot/pivot_root for filesystem isolation, Linux namespaces to hide host resources, and cgroups to limit CPU, memory, and I/O, illustrating core container technologies with practical code snippets.
The article traces Docker’s evolution from a solution for app packaging and PaaS challenges to a developer‑centric platform that introduced Swarm, highlighting how its container technology reshaped cloud‑native computing and sparked a new ecosystem.
This article explains how Kubernetes forwards packets from the initial web request through pod network namespaces, the role of the pause container, veth pairs, bridges, CNI plugins, and iptables‑based service NAT, providing a step‑by‑step view of intra‑cluster and external traffic handling.
This article explains the definition of cloud native, its industry impact, technical characteristics, architectural design principles, and the essential technologies—including containers, serverless containers, bare‑metal containers, microservices, serverless computing, specialized chips, networking, and databases—that together enable elastic, resilient, and observable cloud‑first applications.
This article explains cloud native as a design philosophy that maximizes cloud efficiency through elastic, loosely coupled, observable systems, outlines its industry benefits, technical characteristics, architectural principles, and reviews core technologies such as containers, serverless, microservices, networking, chips, and databases.
The article explains how the deep integration of cloud‑native technologies and edge computing, driven by digital transformation, improves resource utilization, unifies infrastructure management, reduces AI workload costs, simplifies device access, accelerates deployment, and enhances autonomy and ROI for enterprises.
This comprehensive guide answers common Docker questions, covering its definition, use cases, advantages, differences from virtual machines, core components, installation steps, storage configuration, image management, container creation, networking modes, data volumes, private registry setup, backup, and MySQL deployment.
This article examines the challenges of running MySQL in Docker containers, highlighting data safety concerns, I/O performance bottlenecks, statefulness issues, and resource isolation limits, while also outlining scenarios where containerization can work and offering practical mitigation strategies.
This article explains the concept of cloud native, tracing its evolution from early cloud computing to CNCF's 2018 definition, and explores key technologies such as containers, Kubernetes, microservices, service mesh, immutable infrastructure, and declarative APIs, while also highlighting modern cloud‑native services.
This article traces the 20‑year evolution of container technology—from early Unix chroot and FreeBSD jail, through Linux namespaces, cgroups and Docker’s image system, to modern orchestration with Kubernetes and cloud‑native runtimes—explaining core concepts, architectures, and best‑practice guidelines for building and managing containers.
This article explains the Kubernetes networking model, covering container‑to‑container, pod‑to‑pod, pod‑to‑service, and external traffic flows, and shows how Linux network namespaces, virtual Ethernet pairs, bridges, iptables, IPVS, LoadBalancers and Ingress controllers work together to route traffic inside and outside a cluster.
This talk walks through Docker’s appeal, its rise to popularity, the underlying container technology history, core architecture, networking, namespaces, cgroups, and common commands, illustrating how containers streamline deployment compared to traditional VMs and why Docker remains pivotal in cloud-native environments.
This guide covers common Docker problems such as migrating storage directories, handling insufficient disk space, missing shared libraries, container deletion issues, network configuration, command usage, and provides step‑by‑step solutions with code examples.
This article explains what technical debt is, why it arises, and how adopting DevOps practices such as cross‑functional teams, automation, infrastructure‑as‑code, containerization, and API‑centric design can identify, track, and repay technical debt to improve system reliability and agility.
This article presents ten practical methods for hardening Kubernetes application manifests, covering securityContext settings such as runAsUser, privileged mode, capabilities, read‑only root filesystem, privilege escalation, Seccomp, resource limits, image tagging, and optional AppArmor/SELinux policies, to reduce attack surface during development and deployment.
This article traces the evolution of software architecture from monolithic to microservice models, outlines the advantages and drawbacks of each stage, and presents a detailed technology stack—including service communication, API gateways, authentication, distributed tracing, logging, configuration, containers, orchestration, and CI/CD—essential for building modern cloud‑native systems.
The article examines WebAssembly's strengths and limitations as a potential Docker alternative, highlighting its portability, security, and edge‑computing advantages while acknowledging Docker's continued relevance for legacy services and complex workloads.
This guide explains Docker's networking fundamentals, covering Linux veth pairs, the default docker0 bridge, container linking with --link, creating custom bridge networks, and connecting containers across networks, complete with command examples and inspection outputs.
This guide compiles 24 practical Docker troubleshooting scenarios—from storage migration and disk space errors to network configuration, NFS mounts, and container management—providing clear problem descriptions, step‑by‑step solutions, and ready‑to‑use command snippets for Linux environments.
Docker Desktop, the integrated Docker IDE, has finally been released for Linux, offering the same experience as on macOS and Windows, while also introducing Docker Extensions, a new SDK, and sparking debate over recent subscription pricing changes that affect enterprise users.
The New Relic 2022 Java Ecosystem Report reveals that while Java 8 still dominates many production environments, Java 11 usage has surged past 48%, vendor market shares have shifted dramatically with Oracle falling to 34.48% and Amazon rising to 22%, and over 70% of Java applications are now running in containers.
This article provides a comprehensive overview of Podman, an open‑source, daemon‑less container runtime, compares it with Docker, explains key architectural differences, and offers detailed instructions on installation, configuration, common commands, rootless usage, volume handling, and migration aliases.
The New Relic 2022 State of the Java Ecosystem report, based on data from millions of applications, reveals a rapid shift from Java 8 to Java 11, growing usage of newer LTS releases, declining Oracle dominance, and a majority of Java workloads now running in containers.
This article introduces the DevOps culture and systematically categorizes a wide range of DevOps tools—including source‑code management, CI/CD, containers, cloud providers, automation, monitoring, project management, and secret management—to help teams improve productivity and collaboration.
This article explains how Linux namespaces achieve resource isolation and how cgroups enforce resource limits, covering the six namespace types, the system calls used to create them, and practical examples of CPU share configuration with Go code and command‑line tools.
This article breaks down the core principles and architecture of Kubernetes, illustrating how master and worker nodes interact, detailing key components such as the API server, scheduler, controllers, kubelet, kube-proxy, and container runtimes, and explains deployment scenarios on major cloud providers.
This guide compiles twenty‑four common Docker problems—from oversized storage directories and disk‑space shortages to network misconfigurations, NFS lock errors, and container startup failures—providing clear explanations, step‑by‑step commands, and configuration tweaks to resolve each issue efficiently.
Ephemeral containers are temporary debugging pods in Kubernetes that lack resource guarantees and cannot restart automatically; this guide explains their differences, enabling the feature via kube-apiserver and kubelet flags, creating a sample Tomcat pod, adding an Ephemeral container with kubectl debug, and updating it using raw API calls.
This comprehensive guide explains Docker's core concepts, advantages over traditional VMs, architecture, essential commands, Dockerfile syntax, image management, storage volumes, and networking modes, providing step‑by‑step instructions for installing, configuring, and operating containers on Linux systems.
This article provides a comprehensive overview of Podman, an open‑source container runtime that runs without a daemon or root privileges, compares it with Docker, explains its architecture, and presents essential commands, deployment steps, configuration files, volume handling, and user‑namespace considerations for Linux environments.
This guide walks through nineteen typical Kubernetes problems—from service access and port‑mapping errors to pod init failures, PVC issues, and helm installation glitches—explaining each root cause, providing concise troubleshooting steps, and showing the exact kubectl commands and code snippets needed to resolve them.
This article explains why minimal container images hinder debugging, introduces Kubernetes Ephemeral Containers as a solution, and provides detailed commands and examples for enabling the feature, launching temporary containers, sharing process namespaces, and performing advanced troubleshooting.
This article chronicles Docker’s meteoric ascent as a pioneering container platform, its leadership turmoil, fierce competition with Kubernetes, the 2019 split and sale to Mirantis, and the lasting lessons it offers about the challenges open‑source startups face in sustaining commercial success.
This article introduces Podman, explains how to install it on CentOS, demonstrates pulling and running Nginx, MySQL, and a SpringBoot application, compares Podman with Docker, and shows how to manage containers visually with Cockpit, providing a practical alternative to Docker.
The article examines the drawbacks of running MySQL in Docker containers, highlighting data safety, performance, state management, and resource isolation concerns while also discussing scenarios where containerizing MySQL might be feasible.
This article explains what microservices are, how they differ from traditional monolithic applications, provides an Amazon product‑listing example, discusses containers, compares the two, outlines when to adopt microservices, lists their pros and cons, and describes how Kubernetes supports cloud‑native microservice architectures.
This article provides a detailed technical overview of virtualization, covering its historical background, full and hardware‑assisted virtualization, binary translation techniques, hypervisor architectures, KVM‑QEMU integration, and modern container solutions such as LXC and Docker, while also discussing related cloud‑service market reports.
This article explains how Linux namespaces provide resource isolation while cgroups enforce resource limits, detailing their types, system calls, configuration steps, and practical Go code examples to demonstrate CPU share control in container-like environments.
This article explains the fundamentals of microservices, illustrates them with an Amazon product‑listing example, compares microservices to containers, outlines when to adopt microservices, discusses their advantages and disadvantages, and describes how Kubernetes supports microservice architectures.
This article explains how to monitor microservice architectures, describes log, tracing, and metric monitoring, compares open‑source tracing tools, outlines fault‑tolerance strategies such as timeout, rate‑limiting, degradation, async buffering and circuit breaking, and details access‑security mechanisms including gateway authentication, service‑side auth, and OAuth2.0 token flows, while also introducing container technology and its role in microservice deployment.
This article explains what microservices are, how they differ from traditional monolithic apps, illustrates their use with an Amazon product page example, and explores the relationship with containers and Kubernetes, while outlining benefits, drawbacks, and design considerations for adopting a microservice architecture.
This article provides a comprehensive introduction to Docker, explaining what containers are, how they differ from virtual machines, the role of Linux namespaces and cgroups, and includes step‑by‑step practices for limiting container resources using CPU quotas and task assignment.
This article traces the history of container technology from early Linux Containers (LXC) through Docker’s rise, the emergence of Kubernetes, and explains core concepts such as cgroups, namespaces, OCI standards, and how containers appear as isolated processes from both host and container perspectives.
This article provides a comprehensive guide to microservice monitoring—including log, tracing, and metrics approaches—fault‑tolerance isolation techniques, access‑security mechanisms such as API‑gateway and OAuth2.0, and the role of container technologies like Docker in cloud‑native deployments.
This article explains why Linux routing is essential for container networking, details how routing works during packet transmission and reception, explores routing tables and lookup mechanisms in the kernel, and provides practical commands for enabling forwarding, inspecting, modifying, and testing routing rules.
This article examines why many enterprises struggle to adopt containers and Kubernetes, outlines the four main sources of complexity, and presents a range of open‑source tools, managed services, serverless options, and practical guidance to help teams choose the most suitable solution.
This article clarifies Docker’s true nature as an application container engine, explains its core namespace-based isolation mechanisms, and answers frequent questions about networking, hot updates, and volume mapping, while sharing real‑world deployment experiences and best‑practice recommendations.
This comprehensive tutorial explains Docker's concepts, compares virtual machines with Linux containers, guides you through installation, image and container management, Dockerfile creation, building images, publishing them, and demonstrates three practical methods to deploy WordPress using Docker, including custom builds, official images, and Docker Compose.
The article examines Docker's decline, exploring its failed commercial strategies, internal conflicts, missed Kubernetes partnership, leadership turmoil, and the current attempts to revive the brand under new management while highlighting the broader lessons for cloud‑native ecosystems.
This article examines Docker's evolution from a pioneering container platform to its current struggles, detailing licensing changes, subscription models, internal leadership conflicts, missed opportunities with Kubernetes, and the company's attempts to reposition itself in the cloud‑native ecosystem.
This article provides a comprehensive interview‑style guide to Kubernetes, covering its purpose, master‑node and worker‑node components, detailed architecture, pod health‑checking probes, rolling‑update parameters, image pull policies, label selectors, Service concepts, and common kubectl commands for managing resources.
IBM’s early‑stage CPU Namespace prototype introduces a new Linux kernel namespace that virtualizes logical CPU IDs, enabling containers to see isolated CPU resources, improving consistency, security, and fairness, with test results showing up to 95% memory usage reduction and 64% latency drop without affecting throughput.
RHEL 8.5, the latest Red Hat Enterprise Linux release, brings extensive container, Kubernetes, Ansible system‑role, and performance‑monitoring improvements—including Podman image support, signed container images, rootless OverlayFS, enhanced Cockpit console, and new roles for VPN, Postfix, LVM VDO, and Microsoft SQL Server—making it ready for any platform.
This article demystifies Kubernetes networking by explaining the fundamental design of unique Pod IPs, intra‑node communication via veth pairs and bridges, and inter‑node packet routing across CIDR blocks, providing clear step‑by‑step illustrations of how containers talk within and between nodes.
This extensive guide covers Docker fundamentals, container concepts, installation steps, basic and advanced commands, image lifecycle, volume handling, Dockerfile creation, networking options, Docker Compose orchestration, private registries, Harbor deployment, best‑practice recommendations, and monitoring techniques, providing a complete reference for container‑based development and operations.
This article explains the fundamentals of Kubernetes and Docker, covering container concepts, Linux namespaces and cgroups, Docker's evolution, and a detailed overview of Kubernetes' master‑node architecture and its core components for managing containerised workloads.
This article examines why containerizing MySQL often leads to data‑security, performance, state‑management, and resource‑isolation problems, while also outlining scenarios where MySQL can safely run in Docker with proper strategies and examples.
This article provides a detailed Docker tutorial covering container fundamentals, installation steps, basic commands, image lifecycle, volume handling, Dockerfile creation, image layering, Zabbix deployment, private registry setup, Docker‑Compose orchestration, networking modes, and best‑practice recommendations for container operations.
This comprehensive guide walks you through Docker fundamentals, container concepts, installation, image lifecycle, volume management, Dockerfile creation, networking, registry setup, docker‑compose orchestration, and best practices, providing step‑by‑step commands, code snippets, and diagrams to help you build, run, and manage containers efficiently.
A 2021 Forrester survey of 422 Chinese developers reveals how cloud‑native technologies such as containers, Kubernetes and Serverless are reshaping development roles, boosting productivity, and driving a shift from traditional on‑premise coding to a fully cloud‑native, edge‑enabled ecosystem, while highlighting emerging challenges and opportunities.
The article examines the challenges of running MySQL in Docker containers, highlighting data‑security risks, performance bottlenecks, state‑management problems, and resource‑isolation limits, while also outlining scenarios where containerizing MySQL can still be appropriate.
The article explains why running MySQL in Docker containers can lead to data loss, performance degradation, and inadequate resource isolation, while also outlining specific scenarios where containerizing MySQL may still be appropriate.
The Sysdig 2021 report analyzes container usage across thousands of customers, highlighting the most popular open‑source services, the rise of Go and Prometheus, container density and image size trends, alert strategies, and detailed Kubernetes adoption patterns in cloud‑native environments.
This article explains how Linux signals work, details common signals like SIGTERM and SIGKILL, and demonstrates how to use Dockerfile ENTRYPOINT and CMD in exec form together with Go signal handling to achieve clean, graceful shutdowns of containers.
This article provides a concise, question‑driven overview of Kubernetes, explaining the roles of master and node components, pod networking, scheduling, storage, service exposure, scaling, and controller interactions, while summarizing the essential objects and processes that power a cloud‑native cluster.
This article provides a comprehensive overview of Kubernetes, covering its purpose, architecture components, master and node roles, pod health probes, rolling update controls, image pull policies, service functions, label selectors, DaemonSet and Job resources, as well as pod lifecycle and data persistence options.
This article explains that cloud native is not a fixed definition but an evolving vision and set of best‑practice methods—such as immutable infrastructure, automation, sidecar architecture, and Kubernetes—that enable software to be born, grow, and operate efficiently in the cloud while reducing cost and complexity.
This article explains how Docker leverages Linux namespaces to isolate system resources, outlines the six core namespaces and newer additions, clarifies common misconceptions such as the Mount namespace flag, and details the internal nsproxy structure that links processes to their namespaces.
This article traces the evolution of software architecture from monolithic applications through vertical splitting, distributed services, and SOA to modern microservices, and then details the essential technology stack—including service communication, API gateways, authentication, fault tolerance, logging, configuration, containers, orchestration, and CI/CD—required to build scalable, resilient cloud‑native systems.
The article explains why artifacts should be built only once and treated as immutable, using containers as the ideal vehicle, and warns against the anti‑pattern of rebuilding from source code at each pipeline stage, which slows pipelines and creates inconsistent production releases.
This article explains the origins of DevOps, its evolution from agile practices, its deep integration with containers and Kubernetes, and demonstrates a complete CI/CD pipeline using tools like Jenkins, Gogs, Nexus, and SonarQube to achieve automated, end‑to‑end software delivery.
This article explains what Docker is, its underlying architecture—including namespaces, cgroups, and union file systems—its client‑server model, its core concepts such as images and containers, its installation methods, a step‑by‑step Koa hello‑world example, and how to migrate containers using export and import commands.
The CNCF 2020 China Cloud Native Survey of 439 participants reveals rapid growth in serverless adoption, a surge in container and Kubernetes usage, expanding service mesh deployment, and increasing reliance on open‑source automation tools, highlighting China’s emerging role as a major CNCF contributor.
This comprehensive guide walks you through Docker's core concepts, installation on multiple operating systems, image handling, container lifecycle commands, building web services with Apache, Nginx, Python and MySQL, and advanced monitoring techniques using cAdvisor, Prometheus, Grafana, and Kubernetes, providing practical examples and command‑line snippets for each step.
The CNCF 2020‑2021 Cloud Native Survey in China reveals rapid growth in container usage, widespread adoption of Kubernetes, increased reliance on public cloud, expanding CI/CD and serverless practices, and a surge in the use of CNCF projects, highlighting the maturing cloud‑native ecosystem across Chinese enterprises.
This article walks through installing Docker Desktop on Apple M1 Macs, explains required Rosetta support, shows how to run and manage containers—including a Redis example—covers Docker Desktop preferences, resource settings, and built‑in Kubernetes, and highlights practical tips and known limitations.
This article introduces Docker as an open‑source container platform, explains how containers run on Linux and Windows hosts, describes Windows Server and Hyper‑V container runtimes, and compares Docker containers with traditional virtual machines, highlighting resource efficiency, isolation, and deployment advantages.
This guide provides a comprehensive collection of Docker commands for inspecting container information, managing images (listing, searching, pulling, removing, building), and operating containers (starting, stopping, attaching, executing commands, viewing logs, inspecting, committing, and copying files) with practical examples.
This article explains how containers have reshaped modern IT by enabling faster, more agile software delivery, improving resource efficiency, enhancing security through isolation, and powering DevSecOps, while also covering Docker's role, Kubernetes orchestration, Windows container support, and future trends.
This article provides a comprehensive overview of modern DevOps practices and popular tools—including version control, containerization, orchestration, automation, collaboration, and monitoring—explaining their purposes, key features, and how they fit into the software delivery lifecycle.
CoreDNS is a modern, plugin‑based DNS server designed for containerized and Kubernetes environments, offering simple configuration, memory‑safe Go implementation, and tight integration with cloud‑native ecosystems, while also discussing its advantages, limitations, and relationship with the CNCF.
This article explains the Kubernetes pod network concept, describing how each pod receives a unique IP, how intra‑node and inter‑node pod communication works, and the role of the infra container and network bridges in enabling seamless IP addressing across the cluster.
This article explains the evolution of virtualization—from early hypervisors and Popek‑Goldberg requirements through full and para‑virtualization, hardware‑assisted techniques, KVM‑QEMU integration, and finally ultra‑light solutions like firecracker—highlighting their roles, trade‑offs, and impact on cloud computing.
