This article explains the concepts of blocking and non‑blocking I/O, I/O multiplexing mechanisms such as select, poll and epoll, and the differences between synchronous and asynchronous I/O, then demonstrates Java implementations of BIO, NIO and AIO with sample code.
This guide explains why a Jenkins agent fails to start with the error "provided port: 8182 is not reachable" and provides step‑by‑step troubleshooting methods such as network testing, Docker port mapping verification, and ensuring proper communication between the agent and master nodes.
This article explains Calico’s IPIP networking mode in Kubernetes, detailing its architecture, core components, routing behavior, packet encapsulation, and practical verification through ping tests, route inspection, and packet captures, helping readers understand cross‑node pod communication.
This article examines Calico’s IPIP networking mode in Kubernetes, detailing its architecture, core components, IPIP vs BGP operation, route analysis, packet‑capture findings, and pod‑to‑service communication to illustrate how IP encapsulation facilitates cross‑node traffic.
This guide walks through systematic troubleshooting of Java server problems—including CPU spikes, memory leaks, disk I/O bottlenecks, and network timeouts—by using native Linux tools and JVM utilities such as ps, top, jstack, jstat, iostat, vmstat, and netstat to pinpoint root causes and apply targeted fixes.
This guide lists essential Linux commands for retrieving comprehensive hardware information—including CPU, memory, disk, network interfaces, PCI, USB, SCSI, and BIOS details—along with example outputs and explanations for each category on an Ubuntu 16.04 system.
This article analyzes why Kubernetes pods experience occasional one‑second connect() delays due to SNAT port‑collision issues in the iptables conntrack table, explains the underlying networking mechanisms, and offers practical mitigation techniques such as random‑fully SNAT selection and long‑lived connections.
This article explains the step‑by‑step process by which kubelet creates a sandbox container, invokes the CNI interface, runs Calico’s ADD command, and sets up routes, virtual interfaces, and IP allocation for pods in a Kubernetes cluster, including relevant Go code excerpts.
This article investigates why OkHttp timeouts appear ineffective in a Retrofit‑RxJava network stack, examines the internal flow of connectTimeout, readTimeout and writeTimeout through StreamAllocation, AsyncTimeout, and the Watchdog thread, and proposes configuration adjustments to avoid request stalls.
This article provides a comprehensive, diagram‑driven explanation of Kafka’s architecture, covering producers, consumers, topics, partitions, replication, Zookeeper coordination, controller election, state machines, and the NIO‑based network model, helping readers understand the design philosophy and practical configuration implications.
This guide explains the fundamentals of network packet loss, illustrates how packets are sent and received, and provides step‑by‑step troubleshooting methods for hardware NIC, driver, kernel stack, TCP/UDP, and application‑level issues on Linux systems, complete with command examples and visual diagrams.
This guide compiles seventeen common Docker problems—including storage directory migration, disk space shortages, missing libraries, container corruption, network misconfigurations, and command‑line quirks—along with step‑by‑step solutions, configuration tweaks, and command examples to help engineers quickly diagnose and resolve container issues.
This guide walks you through essential Huawei switch commands, covering user and view modes, VLAN creation, port link types, batch operations, initial login procedures, service activation, link aggregation, DHCP setup, and flow‑control configuration, all illustrated with step‑by‑step screenshots.
This article details a real-world case where a JD Cloud engineer overcomes Kubernetes service limitations to enable external access to ClusterIP services and pods, exploring service types, network routing, packet capture analysis, and the solution of enabling kube-proxy’s masquerade‑all feature.
This article walks through the complete lifecycle of a browser request—URL parsing, DNS lookup, TCP handshake, OSI‑layer transmission, caching strategies, HTML rendering, and performance optimizations—mirroring real interview questions faced by front‑end engineers.
This guide walks through a systematic four‑step approach—CPU, disk, memory, and network—to pinpoint Java service failures using tools like jstack, jmap, top, vmstat, iostat, jstat, netstat, ss, and tcpdump, covering OOM, GC, off‑heap, and TCP state problems.
This article explains how NetEase Cloud's audio‑video service overcomes the limitations of TCP in poor network conditions by adopting a QUIC‑based acceleration proxy architecture, detailing its design, key optimizations, and performance gains in latency, packet loss resistance, and bandwidth utilization.
This article introduces LVS, a layer‑4 load‑balancing tool, explains its advantages over layer‑7 solutions like Nginx, describes how combining LVS with Nginx and Keepalived creates a highly available, horizontally scalable architecture, and details the three scheduling modes VS/NAT, VS/TUN, and VS/DR.
This guide offers a practical overview of essential Linux networking tools—including netstat, ss, sar, iftop, and tcpdump—explaining how to monitor connections, analyze traffic, capture packets, and tune kernel parameters to handle massive connection loads efficiently.
This article dissects Linux's synchronous blocking network I/O implementation, explaining how socket creation, recv handling, and soft‑interrupt processing each incur context‑switch overhead that makes BIO unsuitable for high‑concurrency server workloads.
This article explains how Redis communicates over TCP using a simple, fast‑parsing, human‑readable protocol, details the unified request format introduced in Redis 1.2, and illustrates request and response structures—including single‑line, error, bulk, and multi‑bulk replies—with concrete examples.
This article walks through the complete journey of a URL entered in a browser, covering URL parsing, DNS lookup, TCP handshake, OSI‑layer packet transmission, caching strategies, HTML parsing, rendering pipeline, and practical performance‑optimisation tips.
This article details the background, architecture, step‑by‑step troubleshooting, analysis of network and server queues, and the final configuration changes that resolved the intermittent slow response times of the Octavia load‑balancer API in an OpenStack environment.
This article provides two practical approaches, complete with theory, kernel tuning, source code links, and detailed step‑by‑step commands, enabling readers to set up and verify one million concurrent TCP connections on Linux systems.
The article explains how Dubbo can use the Protostuff library as a drop‑in replacement for .proto files to perform Protobuf TLV serialization, detailing the wire‑type encoding, Maven setup, POJO example, byte‑level analysis, Dubbo configuration, and tips for reducing serialization overhead.
The article explains how to use the Linux commands ifconfig, ifup/ifdown, and route for querying and modifying network interfaces, IP addresses, subnet masks, MTU values, and routing tables, providing example usages and practical tips for immediate effect.
This article provides a detailed, front‑end‑focused walkthrough of the complete browser request‑response lifecycle—from URL parsing and DNS lookup through TCP connection, HTTP handling, HTML/CSS parsing, JavaScript execution, to final page rendering—highlighting key concepts, common pitfalls, and optimization tips.
This article explores how KubeVirt extends Kubernetes to manage virtual machines, compares it with OpenStack, details technical selection, core components, CRDs, storage and networking options, and shares practical SDK usage and migration experiences for cloud‑native virtualization.
This article provides a thorough, step‑by‑step guide to using the Linux sar command for real‑time and historical monitoring of CPU, memory, I/O, and network statistics, including syntax, sample outputs, installation tips, common pitfalls, and data‑export techniques.
This article examines the challenges of running both VMs and containers in a hybrid OpenStack‑Kubernetes environment, evaluates KubeVirt against alternatives such as Virtlet and Kata, and provides detailed guidance on KubeVirt architecture, CRDs, storage, networking, SDK usage, and integration with internal platforms.
This article explains Kubernetes' core networking model, details the various Service types (PodIP, HostPort, NodePort, ExternalIP, LoadBalancer, ClusterIP), describes Cilium's eBPF/XDP implementation for high‑performance load balancing, and presents performance benchmarks and recent BPF kernel extensions.
This article explains the background of Server Load Balancing (SLB), describes its three transmission modes—reverse‑proxy, transparent, and triangular—and provides detailed packet‑level analysis of TCP/HTTP interactions for each mode, highlighting configuration nuances and security considerations.
This article introduces the fundamentals of network I/O for the DBLE database system, covering the TCP/IP protocol stack, the MySQL application‑layer protocol, and the performance differences between BIO and NIO approaches, laying the groundwork for deeper source‑code analysis.
This article introduces the Linux ss command for displaying socket statistics, compares its speed and capabilities with netstat, provides common usage examples, explains state filters, and shows why ss is the preferred tool for efficient network monitoring and troubleshooting.
This guide walks you through constructing a 28‑core Raspberry Pi 3B cluster named Kraken, upgrading it with USB gigabit adapters, configuring Docker Swarm and Kubernetes, and measuring performance improvements for self‑hosting a WordPress site.
This guide provides a concise reference of curl’s most commonly used command-line options—including setting user agents, handling cookies, sending POST data, uploading files, managing redirects, limiting bandwidth, and debugging—offering developers a quick cheat‑sheet to replace graphical tools like Postman.
This guide explains how to replace the deprecated ifconfig tool with the powerful ip command, covering how to display interface details, enable or disable interfaces, assign and remove temporary IP addresses, inspect routing tables, view ARP entries, and check network statistics on modern Linux distributions.
This guide explains how to start, stop, restart, enable, and disable the firewalld service on CentOS 7, add or remove ports, list open ports, and perform related queries using firewall‑cmd and ss commands.
This article provides a comprehensive overview of server fundamentals, covering definitions, high‑performance characteristics, core components such as CPU, memory, disks and RAID, various CPU architectures, server classifications, C/S and B/S models, and detailed explanations of network interface cards, their functions, classifications, port types, and cable options.
This guide details a systematic approach to diagnosing Java service failures by sequentially checking CPU, disk, memory, and network issues, using tools like ps, top, jstack, jstat, iostat, jmap, and netstat to pinpoint root causes and apply appropriate fixes.
The article outlines five common performance problems affecting Salesforce SaaS deployments—location latency, bandwidth competition from multimedia traffic, low‑quality bandwidth, ineffective caching, and heavy plugin usage—and provides practical mitigation strategies for IT teams to ensure reliable user experiences.
This article provides a systematic, step‑by‑step guide for diagnosing and resolving Java runtime problems—including CPU spikes, memory leaks, disk I/O bottlenecks, network timeouts, and GC inefficiencies—by using native Linux tools and JVM utilities such as top, ps, jstack, jmap, jstat, iostat, vmstat, pidstat, netstat, ss, and tcpdump.
This article provides a systematic, step‑by‑step guide for diagnosing Java production incidents by examining CPU, disk, memory, GC, and network layers, illustrating the use of tools such as jstack, jmap, jstat, vmstat, iostat, netstat, ss, and tcpdump with concrete command examples and visual aids.
This article explains the background of Server Load Balancing (SLB), details its three transmission modes—reverse‑proxy, transparent, and triangle—and analyzes packet exchanges using Tcpdump and Wireshark to illustrate how client requests are processed and responses returned in each mode.
The weekly roundup covers China's first financial blockchain standard, Intel's 11th‑gen Tiger Lake CPUs, Linux From Scratch v10, Microsoft's deep‑fake detection tool, a record‑scale brain‑inspired computer, a global traffic dip caused by a Level 3 BGP outage, TSMC's AI‑powered chip‑data processing, advances in Bayesian neural networks, and a SIGIR paper on two‑stage question matching.
This article provides a step‑by‑step troubleshooting guide for Java production incidents, covering CPU, disk, memory, GC, and network problems with practical commands, analysis techniques, and tools such as jstack, jmap, iostat, netstat, and native memory tracking.
This article provides a detailed, step‑by‑step methodology for diagnosing and resolving common Java production problems—including CPU spikes, disk bottlenecks, memory leaks, garbage‑collection anomalies, and network timeouts—by leveraging native Linux tools and JVM utilities such as ps, top, jstack, jmap, jstat, iostat, vmstat, pidstat, and netstat.
This guide explains how to configure HTTP/HTTPS proxies for Docker's daemon via systemd, set per‑container proxy settings through the Docker config file, and pass proxy arguments during image builds, covering common pitfalls and network isolation considerations.
The article explains how to achieve Kubernetes high availability by designing a three‑node control‑plane with stacked etcd, using pod anti‑affinity, tuning node‑monitor timers, handling stale endpoints, configuring TCP keep‑alive, managing node taints and eviction, and choosing RWX storage or appropriate StatefulSet strategies to minimize service disruption after node failures.
The article explains how to bypass internal network restrictions by configuring a Java HTTP proxy, provides demo code for setting and using the proxy, and includes utility methods for proxy validation and request configuration.
A real‑world incident showed that a 0% CPU idle rate can mask severe disk IO wait, leading to thread exhaustion in a SpringBoot order service, and the article explains how IO, DMA, Java thread states, and various Linux network IO models interact while offering practical mitigation tactics.
This article provides a step‑by‑step methodology for diagnosing and resolving common online failures in Java services, covering CPU bottlenecks, disk I/O problems, memory leaks, garbage‑collection inefficiencies, and network anomalies such as timeouts, TCP queue overflows, and RST packets.
This comprehensive guide walks you through Chrome DevTools panels—including Console, Elements, Network, Sources, Performance, Lighthouse, Security, and advanced commands—detailing shortcuts, core methods, debugging techniques, performance metrics, and practical tips for front‑end developers to optimize and troubleshoot web applications.
This article explains how to use Chrome DevTools' Performance panel to record and analyze page load, interaction, network, rendering, memory, and flame graph data, helping front‑end developers identify bottlenecks such as long white‑screen times, resource loading delays, and heavy scripting.
This article explains how the Internet is built from nodes and links, the roles of ISPs, IXPs, and content providers, the function of routing tables and protocols, the OSI layered model, bandwidth sharing, and common security threats, providing a comprehensive overview of modern network architecture.
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.
Discover four high‑usage Linux monitoring utilities—iotop, htop, IPTraf, and Monit—that help you quickly diagnose I/O, CPU, memory, network, and process issues, with visual insights and flexible alerting to keep single or multiple servers running smoothly.
This guide explains Linux network fundamentals, shows how to view and configure network interfaces using ifconfig, ip, and the nmcli tool, and provides step‑by‑step examples of editing ifcfg files and applying changes on CentOS 7 systems.
This article explains what load balancing is, why it is essential for scaling web services, outlines the four OSI‑layer classifications, compares popular software balancers such as LVS, Nginx and HAProxy, and reviews common static and dynamic load‑balancing algorithms with their advantages and use cases.
This article examines the classic C10K problem, explores its evolution to the C10M challenge, and analytically derives the theoretical maximum concurrent connections for servers and clients using five‑tuple calculations, port‑IP combinations, and NAT constraints, while highlighting practical limits and performance considerations.
This article breaks down Linux I/O concepts—including memory, network, and disk I/O—explains the two‑phase request flow, details the web request lifecycle, defines blocking, non‑blocking, synchronous and asynchronous operations, and compares five major I/O models with visual diagrams.
This article explains the fundamentals of I/O, detailing the two-phase request process, the flow of a web request, and the differences between blocking, non‑blocking, synchronous, and asynchronous I/O models, including select/poll, signal‑driven, and AIO approaches.
This article explains the end‑to‑end process of a Kafka producer sending a message to a broker, covering client components, the internal cache storage model, partition selection logic, and the workings of the sender thread and network client.
This article explains core network concepts—including protocols, packet structures, the OSI and TCP/IP layer models, TCP three‑way handshake, sliding windows, congestion control, packet sticking and splitting, as well as HTTP/HTTPS basics and their headers—providing a solid foundation for troubleshooting and designing distributed services.
This guide explains how qrcp creates a QR‑coded URL to bind a temporary web server for seamless file transfers between computers and mobile devices, covering its inner workings, installation via Go or binary releases, and detailed command‑line usage for sending and receiving files.
This article presents a systematic approach to diagnosing and resolving Java runtime problems by examining CPU usage, disk I/O, memory consumption, garbage‑collection behavior, and network anomalies, offering practical commands, analysis techniques, and visual aids to pinpoint root causes in production environments.
This article presents a comprehensive front‑end performance checklist covering network optimizations like OCSP stapling, IPv6 adoption, HTTP/2 deployment, HTTP/3 readiness, HPACK compression, security hardening, testing workflows, continuous monitoring, and quick‑win tactics to dramatically improve page load times and user experience.
This article explains common IO latency problems, introduces how to define and refine IO models, lists disk and network evaluation tools, describes key monitoring metrics, and provides practical tuning methods and case studies for improving storage and network performance.
This guide explains how to install, configure, and run tcpcopy and its companion intercept tool to redirect live traffic for realistic pressure testing, including command examples, parameter details, Jenkins integration, and common troubleshooting steps.
NB‑IoT provides a telecom‑grade, low‑power solution for densely populated live‑event venues, delivering up to 50 000 devices per base station with enhanced indoor coverage, reliable data transmission via CoAP and MQTT, and configurable latency modes that bridge the gap until widespread 5G deployment.
This article experimentally explores Nginx's keepalive settings—HTTP keepalive_timeout, proxy_read_timeout, and TCP so_keepalive—showing how different browsers, upstream delays, and TCP probes affect connection lifetimes and what practical steps administrators can take to troubleshoot unexpected disconnects.
The article outlines four key dimensions for extreme HTTP performance optimization—encoding efficiency, channel utilization, transmission path, and information security—explaining how advances like binary encoding, multiplexed streams, TCP/QUIC tuning, and TLS 1.3 together reduce latency, boost concurrency, and enhance user experience.
This article details the step‑by‑step evolution of Mafengwo's Kubernetes network—from early Flannel VXLAN setups, through a VPN‑server bridge for external access, to a MAC‑VLAN CNI solution—highlighting design principles, challenges, and recent optimization plans for large‑scale Java micro‑services.
A Kubernetes user reported intermittent “No route to host” errors during Deployment rolling updates, and this article analyzes common connection‑related errors, explains how IPVS weight handling and source‑port reuse cause the issue, and provides mitigation strategies such as preStop hooks, readiness probes, scaling, and anti‑affinity.
This guide explains the most common Windows networking commands—ping, ipconfig, arp, traceroute, route, nslookup, netstat, and net—detailing their purpose, syntax, useful options, and example outputs to help you diagnose connectivity, routing, and configuration issues efficiently.
QNAT is a high‑performance, open‑source x86 NAT solution developed by 360 OPS, featuring flexible address‑pool selection, session limits, traffic pass‑through, detailed session logging, and a CLI management interface, and is deployed in many IDC and office network egress points.
The article explains that the global pool of 4.3 billion IPv4 addresses has been fully allocated, outlines the historical timeline of regional exhaustion, describes mitigation techniques such as address reuse and NAT, and makes a compelling case for transitioning to IPv6 with its vastly larger address space and technical advantages.
The presentation at the 2019 Shanghai Open Source Infrastructure Summit introduced Kube-OVN, an open‑source CNI that ports mature OpenStack networking concepts to Kubernetes, outlining its design principles, architecture, current release status, and future roadmap.
A detailed DBA interview walks through the diagnosis of excessive Oracle RAC GC wait events, revealing that cross‑instance queries, network latency, NIC bonding mode, and unbalanced IRQ handling together caused the slowdown, and shows step‑by‑step fixes that finally eliminated the problem.
This article analyzes why instant‑messaging (IM) messages can arrive out of order due to time discrepancies, network behavior, and multithreading, and proposes a comprehensive design using global sequence numbers, channel‑aware routing, client‑side caching, and ACK‑based flow control to guarantee ordered delivery.
This article explains the role of load balancers in large-scale internet applications, introduces Linux Virtual Server (LVS) as a four‑layer software load‑balancing solution, describes its architecture, NAT/TUN/DR forwarding methods, and details various static and dynamic scheduling algorithms such as Round Robin, Weighted Least‑Connection, and locality‑based strategies.
This article explains Alibaba Cloud Kubernetes cluster networking, detailing the flannel‑based implementation, the three‑level configuration (cluster, node, pod), the role of Cloud Controller Manager, virtual bridge cni0, and how pods achieve local, intra‑node, inter‑node, and external communication.
This article walks through practical planning, creation, and fine‑tuning of an Alibaba Cloud Kubernetes cluster, covering network design, API server exposure, security groups, master and worker sizing, deployment manifests, service decoupling, and operational best practices.
The latest Kube-OVN release introduces traffic mirroring, IPv6 beta support, an IP‑conflict‑checking webhook, CRD‑based subnet management, and Go module dependency handling, while also summarizing the project’s core networking capabilities and its role in extending Kubernetes with OVN features.
This article walks through capturing and dissecting an HTTP request with Wireshark, explaining TCP three‑way handshake, window scaling, SACK options, four‑way termination, and Keep‑Alive mechanisms, and shows how browsers may differ in connection handling.
This article explains how incorporating hosted‑cloud physical servers into UCloud's UK8S cluster enables seamless hybrid‑cloud operation by improving resource utilization during low‑traffic periods, simplifying network, storage, and load‑balancing configurations, and reducing the operational overhead of managing separate Kubernetes clusters.
Load balancing distributes incoming traffic across multiple servers to improve performance, reliability, and scalability, and this article explains its purpose, the differences between layer‑2, layer‑3, layer‑4 and layer‑7 balancing, common software solutions like LVS, Nginx and HAProxy, and various static and dynamic load‑balancing algorithms.
This comprehensive guide explains why load balancing is essential for high‑traffic websites, details vertical and horizontal scaling, compares DNS, IP, link‑layer, and hybrid approaches, outlines common algorithms such as round‑robin and weighted, and reviews hardware versus software solutions.
This article explains the fundamentals of peer‑to‑peer (P2P) download technology, its advantages over traditional client‑server models, the detailed download workflow, and the testing and monitoring approaches used to evaluate performance, stability, and crash rates.
This article details 360 Search's journey of constructing a Kubernetes‑based private cloud, covering its evolution, network and storage designs, logging pipeline, the Wayne management platform, encountered pitfalls, and future open‑source plans, offering practical insights for similar deployments.
The article outlines practical Elasticsearch security measures—including network isolation, removal of public IPs, non‑root operation, port changes, and user authentication with the open‑source Search Guard plugin—to protect against data leaks and unauthorized access.
Meitu’s container platform, built on Kubernetes with Calico networking, a custom Nginx load‑balancer, unified logging, refined scheduling, autoscaling, and comprehensive monitoring, enables seamless multi‑cluster hybrid‑cloud operations for its hundreds‑of‑millions‑user services while providing CI/CD tooling and future‑ready extensions such as service mesh and edge computing.
This article analyzes whether the entire Chinese population could be added to a single WeChat group, examining user statistics, message volume, required bandwidth, CPU processing limits, Moore's law projections, supercomputer alternatives, hardware costs, storage demands, and practical challenges, concluding that it is theoretically possible but practically infeasible.
This guide explains the purpose of DNS, the role of the /etc/hosts file, the different DNS record types, and provides step‑by‑step instructions for installing BIND on Linux, configuring master, slave and cache servers, and managing zones and records.
This guide compiles a comprehensive set of Linux commands—using awk, grep, netstat, and more—to help you analyze web server logs, track traffic, identify top IPs, monitor connection states, and detect performance bottlenecks on an Alibaba Cloud ECS instance.
This article explains the limitations of single‑connection request handling, demonstrates the performance benefits of multiplexing, and details a .NET Core test that reaches a million requests per second with low latency using Protobuf messages and BeetleX integration.