Tagged articles
namespace
48 articles · Page 1 of 1
Containers replace heavy VMs by sharing the host kernel, using namespaces for isolation and cgroups for resource limits, while immutable layered images lock down the runtime environment, enabling millisecond‑scale scaling, higher density, and standardized deployment that solves the elasticity, cost, and consistency challenges of million‑QPS services.
Elastic Scalingcgroupcontainers
0 likes · 16 min read

This guide explains how to achieve robust multi‑tenant isolation in a shared Kubernetes cluster by combining Namespace with the Hierarchical Namespace Controller (HNC), covering isolation dimensions, permission and network policies, resource quotas, hierarchy design, verification steps, and high‑risk operation safeguards.
HNCKubernetesNetworkPolicy
0 likes · 29 min read

This article provides a comprehensive, step‑by‑step analysis of Kubernetes Pods, covering their design as a shared‑namespace container group, the role of the pause (infra) container, creation flow, lifecycle phases, resource requests and limits, QoS classes, scheduling mechanics, volume types, and detailed troubleshooting techniques with concrete command‑line examples.
KubernetesPodScheduling
0 likes · 30 min read

This article explains why Kubernetes namespaces are essential for logical isolation, outlines their core functions such as resource naming separation, RBAC scopes, quota limits and network policies, and provides practical commands, YAML examples, troubleshooting tips, and automation strategies for managing namespaces at scale.
KubernetesNetworkPolicyRBAC
0 likes · 8 min read

This article explains Python’s LEGB rule—Local, Enclosing, Global, Built‑in scopes—detailing each namespace with clear code examples, demonstrating name resolution order, performance impacts, and practical best‑practice tips such as minimizing globals, using nested scopes, and avoiding built‑in overrides.
Best PracticesLEGBnamespace
0 likes · 12 min read

This article explains Docker's architecture, covering how images serve as read‑only templates, how registries store and distribute images, and how containers use namespaces and cgroups to provide lightweight, isolated, and portable runtime environments for modern cloud‑native applications.
DockerImagecgroup
0 likes · 4 min read

This guide walks through Docker container fundamentals, covering how to run containers with CMD or ENTRYPOINT, keep them alive, attach or exec into them, stop/start/restart, pause/unpause, remove, apply memory, CPU and block I/O limits, and explains the underlying cgroup and namespace technologies that enforce isolation and resource control.
DockerResource Limitscgroup
0 likes · 18 min read

This article explains how Docker achieves lightweight, secure container isolation by leveraging Linux kernel namespaces—including PID, Network, Mount, IPC, and optional User namespaces—detailing each type’s role, benefits, and practical examples such as process visibility and network stack separation.
Dockercloud-nativecontainer
0 likes · 6 min read

This guide explains the differences between Python's import statements—including "import X", "from X import Y", and "from X import *"—covers dynamic imports with __import__, sys.path handling, PYTHONPATH, PEP8 import ordering, __all__ usage, and the role of __name__ in module execution, helping you write cleaner, conflict‑free code.
Modulesdynamic importimports
0 likes · 10 min read

This article dissects the GPUMounter project's implementation of dynamic GPU device mounting to a pod, detailing the roles of cgroups (v1 and v2) and Linux namespaces, and provides step‑by‑step command‑line examples and a CLI tool for practical use.
GPUKubernetescgroups
0 likes · 13 min read

This article explains the inner workings of Python closures by tracing how nested functions are compiled into bytecode, how the CPython VM creates cell objects, binds them via the func_closure field, and stores variables in the localsplus array for static access.
CPythonFunctionPython
0 likes · 18 min read

This guide explains how to run Docker containers, keep them alive, enter them, manage their lifecycle, apply best practices, set resource limits for memory, CPU, and I/O, and understand the underlying cgroup and namespace technologies that isolate and control container behavior.
Dockercgroupcontainers
0 likes · 14 min read

This article explains how Linux creates processes using fork, vfork, clone and pthread_create, reveals the role of the init process, explores clone flags and namespace checks in the kernel, and shows why understanding these fundamentals demystifies container startup.
Linuxcontainerfork
0 likes · 7 min read

This article introduces the "You Call This Thing Cloud Native" series by tracing the evolution of container technology—from early virtual machines and Linux namespaces to Docker’s image system—explaining why containers surged in popularity around 2013 and what fundamentals readers should grasp.
cgroupcontainersnamespace
0 likes · 7 min read

This article explains Docker’s core isolation mechanisms, focusing on how Cgroups and PID namespaces create separate process spaces, demonstrating with Ubuntu container commands, and clarifying why each container sees its own PID 1 despite the host’s actual process IDs.
DockerLinuxPiD
0 likes · 6 min read

This article explains Docker’s core architecture—including images, containers, and registries—and details how Linux namespaces, cgroups, and UnionFS work together to provide resource isolation, limitation, and lightweight virtualization, while also offering promotional links to extensive architecture and interview collections.
DockerUnionFScgroup
0 likes · 6 min read

This guide explains Docker's core architecture, lists the most frequently used Docker commands, compares containers with traditional virtual machines, and dives into the underlying Linux technologies—namespaces, cgroups, and union file systems—that make containerization possible.
DockerUnionFScgroup
0 likes · 12 min read

This guide explains why a Kubernetes namespace may remain in a Terminating state, shows how to inspect resources, edit the namespace JSON to remove finalizers, use the Kubernetes API via curl with a proxy, and verify that the namespace is finally removed.
Kubernetescloud-nativedeletion
0 likes · 8 min read

This article explains Kubernetes Limits and Requests, their differences, practical deployment examples, CPU and memory characteristics, namespace ResourceQuota and LimitRange policies, and provides best‑practice guidelines to optimize resource allocation, avoid OOM kills, and prevent CPU throttling.
Best PracticesKuberneteslimits
0 likes · 13 min read

This guide explains Kubernetes namespaces, their purpose for multi‑tenant resource isolation, describes the four default namespaces, and provides step‑by‑step commands to list, create, format, and delete namespaces using kubectl.
cloud-nativekubectlnamespace
0 likes · 3 min read

This article explains how to use GitLab CI and Kubernetes namespaces to automate building, testing, and deploying containerized services, ensuring environment isolation, resource control, traceability, and low operational overhead without introducing additional platforms.
CI/CDDevOpsGitLab CI
0 likes · 11 min read

This article explains Docker's built‑in container networking, describing the three default networks, the four network modes (bridge, container, host, none), how to inspect and configure them with commands, use veth pairs and network namespaces, and perform common container operations such as port mapping and custom bridge creation.
Dockerbridgecontainer
0 likes · 27 min read

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.
DockerLinuxcgroup
0 likes · 8 min read

TafDB, Baidu’s Spanner‑like distributed transaction database built on RocksDB and Multi‑Raft, provides a virtually unlimited metadata layer for cloud data lakes by unifying hierarchical and flat namespaces, minimizing cross‑shard transaction overhead, handling garbage collection, and employing a distributed clock, thus delivering trillion‑scale metadata capacity and tens of millions of QPS with low latency.
Distributed DatabaseMetadata StorageTafDB
0 likes · 21 min read

This article explores how Kubernetes Pods differ from simple containers by examining their underlying implementation, shared network and IPC namespaces, cgroup hierarchies, and the role of the pause sandbox, while also demonstrating how similar pod-like behavior can be achieved using Docker and cgroup tools.
DockerKubernetesLinux
0 likes · 20 min read

The article explains how attackers can break out of Docker containers by exploiting misconfigurations, vulnerable Docker components, kernel bugs, or Kubernetes RBAC errors, illustrates real‑world exploits such as host‑proc mounts and CVE‑2019‑5736, and provides mitigation steps like limiting privileges, updating software, and securing configurations.
Dockercgroupcontainer security
0 likes · 15 min read

This article explains the role of Linux cgroup and namespace technologies in providing resource isolation and security for containers, traces their historical development from early chroot mechanisms to modern Docker and Kubernetes, and details cgroup architecture, core files, migration, delegation, and practical usage examples.
DockerLinuxcgroup
0 likes · 17 min read

This guide introduces beginners to containerization by explaining Docker’s core components, Linux kernel mechanisms, and networking, then progresses to Kubernetes, detailing its architecture, key objects such as Pods, Deployments, Services, and storage concepts, and how they orchestrate distributed container workloads.
ContainerizationDockerKubernetes
0 likes · 28 min read

This article explains why Elastic Job tasks can clash in ZooKeeper when they share the same name but different classes, and shows how using the namespace property—especially tying it to the Spring Boot application name—effectively isolates jobs and prevents such conflicts.
ElasticJobjob-conflictnamespace
0 likes · 7 min read

This talk walks through the evolution of containerization—from early chroot and jails to modern Kubernetes—explains Redis’s core features, compares various container solutions for Redis deployment, and offers practical guidance on installation, scaling, monitoring, and fault recovery in both single‑instance and clustered environments.
ContainerizationDockerKubernetes
0 likes · 30 min read

This article demonstrates how to use PHP namespaces with the `use` keyword, create aliases for classes, functions, and constants, incorporate traits, and capture variables in anonymous functions, providing clear code examples for each concept.
aliasclosurenamespace
0 likes · 2 min read

This article describes a Laravel‑based static analysis tool that automatically scans PHP files to detect missing namespace imports, unresolved class references, and undefined class constants, using regex and token_get_all, and integrates the checks into GitLab CI for early error prevention.
GitLab CILaravelclass-constant
0 likes · 11 min read

This comprehensive guide walks beginners through Kubernetes fundamentals, covering the architecture, core components such as Pods, Deployments, Services, Ingress, and Namespaces, and provides step‑by‑step instructions for configuring kubectl, deploying workloads, managing resources, and troubleshooting common issues.
KubernetesServicekubectl
0 likes · 36 min read

This article explains why Redis creates 16 logical databases by default, how to configure their number, the correct way to treat these databases as namespaces rather than separate stores, and why multiple databases are not supported in Redis Cluster mode.
ClusterConfigurationRedis
0 likes · 6 min read

This article explains how Kubernetes LimitRange lets you set default CPU and memory requests and limits for Pods within a namespace, provides step‑by‑step configuration examples, demonstrates common usage scenarios, and shows how to test and verify the limits, including for PersistentVolumeClaims.
KubernetesLimitRangePod
0 likes · 9 min read

This article explains the concept of multi‑tenant Kubernetes clusters, distinguishes soft and hard isolation, describes common enterprise and SaaS/KaaS scenarios, and provides step‑by‑step guidance on using native Kubernetes features such as RBAC, NetworkPolicy, PSP, OPA, resource quotas, pod priority, node taints, and secret encryption to achieve robust security isolation.
KubernetesNetworkPolicyOPA
0 likes · 14 min read

This article investigates why a Kubernetes Namespace can get stuck in the Terminating state, analyzes logs from the API Server and Controller Manager, explains API group/version mechanics, uncovers a Metrics Server network issue caused by missing VPC routes and RAM role policies, and provides a step‑by‑step fix.
KubernetesMetrics ServerRAM role
0 likes · 11 min read

This article explains fundamental Kubernetes concepts—including containers, pods, nodes, namespaces, services, and labels—highlighting their roles, characteristics, and how they enable lightweight, portable, and efficiently managed cloud‑native applications.
KubernetesPodService
0 likes · 2 min read


21CTOAug 17, 2019 · Cloud Native
Through a charming story of a curious daughter and her father's illustrated guide, the article introduces Kubernetes concepts such as pods, replication controllers, services, volumes, and namespaces, using the adventures of a PHP app named Phippy to make complex container orchestration easy to understand.
PodsReplicationControllerService
0 likes · 7 min read

This guide explains Docker's Namespace and Cgroup mechanisms, shows how to configure them to limit resources and isolate containers, and demonstrates practical commands for protecting container security while highlighting their limitations.
DockerLinuxResource Limitation
0 likes · 16 min read


21CTOJul 18, 2019 · Backend Development
Jakarta EE, the rebranded successor to Java EE, has renamed each specification to clarify its future role, switched from the javax to jakarta namespace, and introduced consistent naming, affecting developers who must adjust dependencies and consider compatibility with servers and frameworks like MicroProfile and Quarkus.
Jakarta EEJava EEMicroProfile
0 likes · 4 min read

Through the whimsical story of a lonely PHP app named Phippy, the article introduces core Kubernetes concepts—containers, Pods, Replication Controllers, Services, Volumes, and Namespaces—using vivid metaphors to help readers grasp how container orchestration works in modern cloud-native environments.
KubernetesPodsReplication Controller
0 likes · 10 min read

The article analyzes a slowdown issue in the 58 Cloud Platform caused by an overloaded API Server and uneven Etcd load, explains the root causes—including load‑balancing failure and missing namespace segmentation—and presents concrete remediation steps such as DNS round‑robin, namespace partitioning, Etcd client upgrade, and cache‑enabled queries.
CachingKubernetescloud-native
0 likes · 15 min read

This guide explains how Kubernetes namespace-level resource management lets administrators set default CPU/memory requests, define minimum and maximum constraints, and enforce resource quotas, with step‑by‑step commands and YAML examples to create namespaces, ResourceQuota objects, and pods while handling quota limits.
KubernetesResourceQuotacloud-native
0 likes · 9 min read

This tutorial explains how to configure default CPU and memory requests and limits for containers in a Kubernetes namespace using LimitRange objects, demonstrates the effect with several pod examples, and shows how to clean up the resources afterward.
DevOpsLimitRangedefault-resources
0 likes · 8 min read

This article provides a comprehensive technical overview of Linux virtualization technologies, covering hardware-assisted CPU VT, chroot system call, cgroup resource control, namespace isolation, and their integration in container solutions like LXC and Docker, with code snippets and architecture diagrams.
KVMLXCLinux
0 likes · 13 min read

Non-modular JavaScript leads to naming conflicts and tangled file dependencies, but adopting a module system like CMD eliminates these issues by encapsulating functionality, simplifying imports with define, require, and exports, and streamlining project structure for scalable front‑end development.
JavaScriptModular Developmentcmd
0 likes · 4 min read

HTML5, widely adopted for audio, video, offline storage and new semantic elements, remains evolving, while the speculative HTML6 proposal envisions namespace‑prefixed custom tags such as logo and html:media, richer metadata, unified APIs, and clearer semantics to improve readability and media handling, though it is not yet finalized.
HTMLHTML6custom tags
0 likes · 10 min read
