This article explains the Linux kernel networking components—veth pairs, Linux bridges, and overlay networks—detailing their creation, configuration, packet flow, and troubleshooting with concrete Docker and Kubernetes examples, commands, and packet‑capture analysis.
This guide explains the fundamentals of Linux bridges, their role in linking network interfaces, and provides step‑by‑step instructions for creating, configuring, and managing bridges using brctl, NetworkManager (nmcli), and iproute2 commands across various distributions.
This article walks through Docker’s built‑in networks, details the four network modes (bridge, host, none, container), shows how to create and inspect network namespaces, configure veth pairs, map ports, set DNS and custom bridges, and provides concrete command‑line examples and diagrams.
This article explains Docker’s various network modes—including bridge, host, none, and container—detailing their architecture, use‑cases, and limitations, and also covers Docker’s network drivers, how to create and connect networks via CLI, and the service discovery and load‑balancing features provided by Docker Swarm.
This guide explains Docker’s various network modes—including bridge, host, none, and container—details each driver’s behavior, shows how to create and configure custom networks with commands, and covers Swarm’s built‑in service discovery and load‑balancing mechanisms for scalable container deployments.
This article provides a comprehensive guide to Docker's networking options, detailing bridge, host, none, and container modes, the various network drivers, configuration commands, and how Docker Swarm enables service discovery and load balancing for scalable container deployments.
This article explains Docker networking fundamentals, covering the main network types (bridge, host, overlay, macvlan, none), their drivers and container modes, how to configure and manage networks with Docker CLI commands, and important security and isolation considerations for containerized applications.
This article walks through Docker's default docker0 bridge, explains how containers obtain IP addresses via veth‑pair interfaces, demonstrates inspecting container IPs, and shows how to create and use custom bridge networks so containers can communicate by name or IP, including adding existing containers to the new network.
This guide explains Docker's three default networks, the four container network modes (bridge, container, host, none), how Linux bridges and veth pairs work, commands for network namespaces, port mapping, custom bridge creation, and practical examples for configuring Docker networking.
This comprehensive guide explains Docker's networking fundamentals, covering network types such as bridge, host, overlay, and macvlan, their drivers, configurations, security considerations, and practical command‑line examples for creating, managing, and troubleshooting container networks in both single‑host and multi‑host environments.
This article explains Docker's container networking concepts—including the CNM model, native drivers, bridge, host, macvlan, none modes, port mapping, overlay SDN—as well as storage options and Compose orchestration techniques for building robust cloud‑native applications.
This article explains the fundamentals of Linux network namespaces and bridge devices, showing how they isolate resources, form hierarchical PID trees, and enable inter‑namespace communication for container platforms like Docker and Kubernetes.
This article explains Linux's virtual network devices—including Tap and Tun virtual NICs, Veth-pair links, Bridge bridges, Network namespaces, VLAN sub‑interfaces, MACVLAN and MACVTAP—detailing their architecture, driver components, configuration commands, and practical examples for building isolated or connected virtual networking environments.
This article provides a comprehensive guide to Docker container networking, covering the default networks, the four network modes (bridge, container, host, none), Linux network namespaces, veth pair creation, and practical container operations such as hostname configuration, DNS settings, port mapping, and custom bridge setup.
This article provides a comprehensive guide to Docker container networking, covering the default networks, the four network modes (bridge, host, none, container), virtual Ethernet pairs, Linux network namespaces, and practical configuration examples such as port mapping and custom bridge creation.
This tutorial explains how to build a functional single‑host container network using Linux network namespaces, virtual Ethernet (veth) pairs, a bridge, IP routing and NAT, covering isolation, inter‑container communication, external connectivity, port publishing and rootless considerations.
This article explains the main features of LuaJ, provides usage examples for calling Java static methods from Lua (including handling signatures and return values), demonstrates how to pass Lua functions to Java, and shows how to embed and execute Lua scripts within Java code.
This article explains how to virtualize network resources on a single Linux host using network namespaces, virtual Ethernet (veth) pairs, bridges, IP routing, NAT, and iptables, enabling containers to communicate with each other, the host, and the external world without writing custom code.
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.
This article explains how to use luaj, a Lua‑Java bridge, to call Java static methods from Lua, pass Lua functions to Java, handle method signatures, check call results, and manage error codes, providing practical code examples for seamless integration.
This guide details Docker's built‑in network drivers, explains the four primary network modes—bridge, host, container, and none—covers creating and managing network namespaces, veth pairs, custom bridges, and common container operations such as port mapping, DNS configuration, and hostname handling.
This article explains Docker's networking fundamentals, covering Linux veth pairs, the default docker0 bridge, container linking with --link, the creation and use of custom bridge networks, and how to connect containers across isolated networks for reliable service communication.
This article explains Docker's built‑in networking, details the four network modes (bridge, host, container, none), shows how to inspect and configure networks with commands like docker network, ip netns and veth pairs, and provides practical examples for port mapping, DNS, and custom bridge creation.
The Xiaohongshu mini‑app runtime uses a dual‑thread container separating a Render UI layer and a Service logic layer, linked by a serialized Bridge, with unified iOS/Android containers, Webpack‑based build outputs, priority‑queued messaging, pre‑loading, and AOP performance monitoring to provide fast, scalable, merchant‑focused mini‑apps.
This guide explains Docker's built‑in network types, the four container network modes, how bridges and veth pairs work, and provides step‑by‑step commands for creating and managing network namespaces and custom bridges.
This guide explains Docker's built‑in network types, the four primary network modes (bridge, host, container, none), how the Docker bridge (docker0) works, how to create and manage Linux network namespaces, veth pairs, and custom bridge networks, plus practical commands for inspection and port mapping.
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 article explains how Docker isolates containers using Linux veth pairs, the default docker0 bridge, the deprecated --link method, and how to create and use custom bridge networks for reliable service‑name communication and cross‑network connectivity.
The article shows how the Lura library uses C++ reflection to build a concise Lua bridge that automatically registers functions, properties, and object lifecycles via userdata and meta‑tables, simplifying bridge code compared to traditional libraries while supporting coroutines and profiling.
This article explains the architecture and workflow of React Native's cross‑platform communication, detailing the JSBridge mechanism, the roles of platform, bridge, and JS layers, and how native modules interact with JavaScript through C++ and JNI, with a concrete setTimeout example.
Learn how to virtualize network resources on a single Linux host using network namespaces, virtual Ethernet devices, bridges, and NAT, enabling isolated containers to communicate with each other, the host, and the external internet without complex code, while covering setup, routing, and port publishing.
This tutorial explains how to create isolated, virtualized network stacks for containers on a single Linux host using network namespaces, virtual Ethernet pairs, a Linux bridge, routing, NAT, and iptables, and shows how to expose container services to the outside world.
This tutorial walks through the fundamentals of single‑host container networking on Linux, covering network namespaces, virtual Ethernet (veth) pairs, bridges, IP routing, NAT, port publishing, Docker network drivers, and rootless container considerations, all with step‑by‑step commands and explanations.
This tutorial explains how to isolate, virtualize and connect container network stacks on a single Linux host using network namespaces, virtual Ethernet pairs, a Linux bridge, routing, NAT and iptables rules, and shows how to expose container services to the external world.
This tutorial walks through building isolated, virtualized networking for containers on a single Linux host using network namespaces, virtual Ethernet pairs, Linux bridges, IP routing, NAT, and iptables rules, enabling inter‑container communication, host access, and external connectivity without writing any custom code.
This article details 58.com’s Swift migration initiative, describing the background of Swift adoption, the objectives of the mixed‑language project, the practical steps for SDK module‑ization, bridging techniques, nullability annotations, macro handling, +load replacements, and future plans for improving Objective‑C to Swift integration.
This article explains how Linux bridge and virtual Ethernet (veth) devices work together to enable communication between Docker containers, covering the creation of network namespaces, veth pairs, bridge setup, kernel implementation details, and packet forwarding processes.
This tutorial walks through creating and configuring a Linux bridge, connecting it to veth pairs and a physical NIC, assigning IPs, troubleshooting ARP issues, and demonstrates common use cases for virtual machines and Docker containers.
This tutorial walks through the fundamentals of Linux bridge devices, showing how to create a bridge with iproute2, connect it to veth pairs, assign IP addresses, attach a physical NIC, and apply the setup in virtual‑machine and Docker environments while explaining common pitfalls and networking behavior.
This article introduces Kraken, a high‑performance, Flutter‑based web rendering engine, detailing its technical background, architecture, bridge implementations, key performance optimizations, extended widget support, and debugging tools, while comparing its rendering flow with traditional WebView and Flutter pipelines.
This article explains from a frontend perspective how JavaScript and native code communicate in hybrid apps, covering injection and interception bridge methods, their implementation details, SDK initialization, message flow, and native event listening with code examples and compatibility considerations.
This article demystifies single‑host container networking by explaining network namespaces, virtual Ethernet pairs, Linux bridges, routing, NAT with iptables, Docker network drivers and rootless container limitations, while providing step‑by‑step commands and code snippets for practical implementation.
This tutorial explains how to build isolated, interoperable container networks on a single Linux host using network namespaces, virtual Ethernet pairs, bridges, routing, NAT, and port publishing, with step‑by‑step commands and practical examples for Docker and Podman.
This guide walks through building isolated single‑host container networks on Linux using network namespaces, virtual Ethernet pairs, bridges, routing and NAT, showing step‑by‑step commands to create, connect, and expose containers, troubleshoot connectivity, and understand Docker’s networking models.
This article explains what JSBridge is, details its implementation using URL interception and iframe tricks, and walks through the full communication flow between a WebView and native code on iOS, including code examples for registration, message handling, and callbacks.
This article explains what JSBridge is, details its implementation using URL interception and iframe tricks, and walks through the registration, message handling, and call flow between WebView and native code on iOS, providing full code examples and a step‑by‑step process overview.
This tutorial explains how to isolate, virtualize, and connect Linux network stacks on a single host using network namespaces, virtual Ethernet pairs, Linux bridges, routing, NAT, and iptables, covering both basic concepts and practical commands for Docker and Podman environments.
This article demystifies single‑host container networking by explaining network namespaces, virtual Ethernet (veth) pairs, Linux bridges, IP routing, NAT masquerading, port publishing, and the differences between Docker and rootless container networking, all with practical command‑line examples.
This article provides a comprehensive overview of key structural design patterns—including Proxy, Adapter, Bridge, Decorator, Facade, Flyweight, and Composite—explaining their definitions, advantages, structure, real‑world scenarios, and complete Java implementations with code snippets and diagrams.
This tutorial walks through building isolated single‑host container networks using Linux network namespaces, virtual Ethernet (veth) pairs, bridges, routing, NAT and iptables, enabling containers to communicate with each other, the host, and the external Internet.
This tutorial explains how to build a functional single‑host container network on Linux by using network namespaces, virtual Ethernet pairs, a Linux bridge, IP routing, NAT with iptables, and port publishing, providing step‑by‑step commands and troubleshooting tips.
This article explains how to virtualize and isolate Linux network resources for containers using network namespaces, virtual Ethernet devices, bridges, routing, and NAT, providing step‑by‑step commands to connect containers, expose ports, and enable external internet access without relying on Docker.
This article explains six fundamental JavaScript design patterns—Constructor, Facade, Proxy, Strategy, Bridge, and State—illustrating their concepts, advantages, drawbacks, and providing clear code examples that demonstrate how each pattern can improve code organization, reuse, and maintainability in front‑end development.
This article introduces React Native, covering its core concepts, cross‑platform features, underlying architecture such as JavaScriptCore, Hermes, the Bridge, Virtual DOM, threading model, hot updates, and provides practical examples for building a modal animation on both iOS and Android.
This article explores how applying classic design patterns—Chain of Responsibility, Strategy, Template Method, Observer, Decorator, and Bridge—can turn repetitive CRUD business code into clean, robust, and extensible solutions, illustrated with real‑world Java examples, practical experiences, and step‑by‑step code snippets.
This article explains the basic networking devices and concepts—including hubs, switches, routers, gateways, routing, static vs. dynamic routing, routing tables, and the differences between bridging and routing—illustrated with diagrams and step‑by‑step examples to clarify how data moves across networks.
WYBridge provides a unified bridge layer for multiple cross‑platform containers—React Native, Flutter, Weex, and Web—standardizing API definitions, registration, parsing, and invocation across Android and iOS, while offering compatibility solutions for legacy method calls and detailing implementation specifics for each platform.
This article explains Docker’s four network drivers (bridge, host, none, overlay), details how the bridge driver creates the docker0 bridge and veth pairs, shows port‑mapping with -p/-P, then covers Kubernetes pod communication patterns, CNI plugins, and provides a step‑by‑step guide to deploying and configuring Flannel with different backends such as vxlan, host‑gw and directrouting.
This article explains Docker's built‑in network drivers, the bridge mode construction and external access, then compares Kubernetes networking requirements and details how Flannel implements pod‑to‑pod communication using overlay networks and packet encapsulation.
This guide walks you through Linux network virtualization fundamentals, explaining how to create and manage Network Namespaces, configure veth pairs and bridges, and enable communication between isolated namespaces using iproute2 commands, complete with practical command examples and troubleshooting tips.
This article details the AutoMan app's transition from native development to a React Native‑based cross‑platform solution, covering background challenges, framework selection, architectural layers, custom components, hot‑update mechanisms, and the accompanying mini‑program publishing platform.
RND (React Node Desktop) is a lightweight cross‑platform desktop framework that merges a React‑based JavaScript layer, an embedded V8‑powered Node runtime, and a native UI engine (Lyra with Yoga layout), employing a dual‑thread model, shared V8 isolate, asynchronous bridge, modular resource handling with hot‑update, and integrated Chrome/VSCode/Electron debugging.
This guide explains Docker's built‑in network drivers (bridge, none, host), shows how to inspect the default docker0 bridge, demonstrates creating a user‑defined bridge network, attaching containers with --network, and verifies connectivity with ping and IP inspection commands.
This article details a two‑month exploration of the Weex framework, covering its architecture, project scaffolding, build commands, demo implementation, environment configuration, caching strategies, native bridging, and a concise comparison with React Native and Flutter to demonstrate its suitability for cross‑platform front‑end development.
The article details a production‑ready Hybrid app bridge built with a custom bridge.js that enables bidirectional communication between Native code and H5 pages, outlines its four‑step nativeCall flow, Android compatibility tricks, protocol categories, event hub, proxy requests, and a suite of reusable functional APIs.
This article thoroughly analyzes React Native’s native event‑handling pipeline, explaining how RCTRootView creates RCTRootContentView and RCTTouchHandler, detailing the touchesBegan/touchesMoved/touchesEnded implementations, and tracing the flow through _updateAndDispatchTouches, RCTEventDispatcher, and the bridge that finally invokes JavaScript callbacks.
This article explores the Weex SDK architecture on iOS, detailing its cross‑platform workflow, the division of JS, bridge, and native layers, the registration of modules and components, and the role of WXSDKInstance in loading and rendering JS bundles.
This guide explains how to use a Huawei router's transparent bridge and VLAN features to enable communication between selected departments while isolating others, detailing the scenario, configuration logic, and step‑by‑step command sequence for setting up bridge groups and VLAN interfaces.
This article explains how to design a hybrid app's communication layer using JSBridge, outlines native‑H5 interaction patterns, presents bridge protocol implementations, discusses UI responsibilities, and describes offline H5 container architecture with local URL routing and update mechanisms.
This article explains the principles, usage, and data flow of Linux’s abstract network devices—including bridges, 802.1q VLANs, TAP, and VETH—showing how to configure them, analyze traffic, and troubleshoot common issues within virtualized environments.
This article explains how Linux hosts use TAP/TUN to simulate virtual switches and layer‑3 devices, detailing four common single‑host virtual network models—NAT, routing, bridge, and isolation—and how they enable communication between virtual machines and external networks.
