This article explains the fundamentals of Kubernetes networking, describes its flat network architecture, reviews common CNI implementations such as Flannel, Project Calico, and Weave Net, and details the various communication pathways including container‑to‑container, pod‑to‑pod, pod‑to‑service, and internet‑to‑service.
This guide explains how to use the Linux ‘ip’ command to view current network settings, configure IP addresses, gateways, DNS, interface states, and perform common troubleshooting tasks such as checking link status, traffic statistics, routing tables, and active IP assignments.
A comprehensive collection of Linux operations interview questions covering topics such as system administration, RAID configurations, load balancing, middleware, MySQL troubleshooting, network monitoring, security, scripting, and best practices for optimizing and maintaining Linux servers.
This article explains the inner workings of the ping command, covering the ICMP protocol, packet formats, echo request/reply mechanics, common ICMP error messages, and how traceroute leverages ICMP to map network paths, providing a solid foundation for network interview questions.
This guide walks through a full manual installation of OpenStack Rocky on a two‑node (controller + compute) environment, covering architecture diagrams, network design choices, core services configuration (DNS, NTP, MySQL, RabbitMQ, Memcached, Etcd), and detailed setup of Keystone, Glance, Nova, Neutron, Horizon and Cinder with all required commands, config files and verification steps.
This comprehensive guide answers over a hundred fundamental networking questions, covering links, OSI layers, backbone networks, LANs, routers, protocols, topologies, security measures, and key concepts such as DHCP, NAT, VPN, and IPv6, providing clear explanations for students and professionals alike.
This article explains the limitations of traditional X86‑DPDK load‑balancing gateways and how Baidu’s third‑generation Universal Networking Platform (UNP) combines programmable ASICs, CPUs, and FPGA acceleration to deliver multi‑terabit throughput, ultra‑low latency, and dramatically lower cost and power consumption.
This extensive guide covers networking fundamentals across all OSI layers, detailing concepts such as links, nodes, protocols, PDU structures, network topologies, TCP/IP encapsulation, transport protocols, application services, security mechanisms, wireless LAN technologies, and key command‑line tools, providing a complete reference for students and professionals alike.
This guide walks through eight frequent Kubernetes networking problems in Tencent Cloud Kubernetes Service—such as cross‑VPC NodePort timeouts, low load‑balancer CPS, DNS resolution delays, apiserver access lag, mis‑configured resolv.conf, liveness‑probe failures, and externalTrafficPolicy = Local timeouts—explaining their root causes and providing concrete kernel, iptables, DNS, and configuration fixes.
This article summarizes the key technical questions and answers from a MiHoYo spring recruitment interview, covering Java string handling, synchronized locks, exception types, operating‑system IPC mechanisms, MySQL indexing and isolation levels, as well as DNS resolution and TCP packet issues.
This article explains the Linux network stack, detailing the TCP/IP model layers and describing in depth how incoming packets travel from the NIC through DMA, interrupt handling, and the kernel's protocol layers to the application, as well as the reverse path for outgoing packets.
This article explains the step‑by‑step process Linux follows to receive network packets from the NIC, pass them through the kernel’s networking stack, and finally deliver them to applications, as well as the reverse path for sending packets from applications to the network.
This article explains why iPads and M‑series MacBooks experience high Wi‑Fi latency during games, identifies Apple’s AWDL protocol as the cause, and provides step‑by‑step instructions to disable AWDL on both macOS and iOS devices.
This article explains the concepts, purposes, and inner workings of TCP keepalive and HTTP keepalive, compares their roles in maintaining network connections, and provides practical guidance on configuring related parameters and handling socket lifecycles in server environments.
This article explains the three main Java I/O models—BIO (blocking), NIO (non‑blocking), and AIO (asynchronous)—detailing their characteristics, differences in blocking behavior, core components like Buffer, Channel, and Selector, and shows how they are applied in popular frameworks such as Netty, Mina, and Dubbo.
This article explains the evolution and architecture of the Domain Name System (DNS), covering its origins, hierarchical domain structure, global server hierarchy, recursive resolution process, private server deployment, protocol packet format, and implementation methods such as UDP/TCP and HTTP DNS, illustrated with diagrams and code examples.
Bob Metcalfe, the 76‑year‑old Ethernet inventor and 3Com founder, recently received the Turing Award; the article chronicles his pioneering work on Ethernet, Metcalfe’s Law, his academic background, entrepreneurial ventures, and lasting impact on computer networking and the modern internet.
This guide walks through configuring port mapping on Windows using netsh and on Linux using iptables, covering query, addition, deletion, enabling packet forwarding, NAT rules, a multi‑VM test environment, and verification with curl commands.
This article traces the Internet’s evolution from Cold‑War‑era research projects like ARPA and ARPANET through the birth of TCP/IP, HTTP, REST, and the rise of SDN, OpenFlow, and P4, highlighting key milestones, standards, and the ongoing push toward fully programmable networks.
This article compiles a technical interview recap covering MySQL MVCC, atomicity and persistence mechanisms, operating‑system page cache and deadlock concepts, TCP reliability and flow‑control, Redis persistence and clustering, as well as distributed transaction and consensus fundamentals.
This article provides a comprehensive overview of the Kubernetes Gateway API, covering the constraints of Ingress resources, L4 routing methods, the role of SIG-NETWORK, reasons behind the API's development, and a preview of deeper technical details.
This guide explains how to enable cross‑cluster pod communication in Kubernetes using Kube‑OVN's OVN‑IC feature, covering prerequisites, single‑node and high‑availability database deployment, automatic and manual route configuration, and cleanup procedures with concrete Docker/Containerd commands and ConfigMap examples.
The article recounts curl creator Daniel Stenberg's celebration of the project's 25th anniversary, highlighting its evolution from a modest URL client to a ubiquitous command‑line tool supporting dozens of protocols, with over 10 billion installations and a vibrant open‑source community.
This article details Taobao's multi‑year journey of deprecating SPDY, boosting IPv6 traffic, building an end‑to‑end IPv6 networking stack, establishing a large‑scale operational system, and sharing technical insights such as APN6, BIERv6, and multi‑connection optimization for future IPv6+ applications.
This article compiles a detailed interview guide covering TCP/UDP differences, three‑way handshake and four‑way termination, flow and congestion control, select/poll/epoll mechanisms, zero‑copy techniques, Redis advantages and persistence, MySQL MVCC and repeatable‑read semantics, as well as core C++ topics and common algorithm questions.
This article explains core Linux kernel networking concepts such as the sk_buff packet buffer, net_device representation of NICs, the relationship between socket and sock structures, layer registration mechanisms, and how Netfilter and routing tables process packets within the stack.
The article explains how HTTP/3 abandons TCP in favor of the QUIC protocol built on UDP, detailing TCP's head‑of‑line blocking, handshake latency, middlebox rigidity, and how QUIC’s reliability, multiplexing, and fast handshakes address these issues while also noting deployment challenges.
This article examines the highly concentrated DPU market, highlighting the dominant global vendors Nvidia, Broadcom and Intel, and provides a detailed analysis of emerging Chinese manufacturers—including NebulaX, Paratus, xFusion, Chiplet, and K2—covering their architectures, performance claims, and strategic positioning.
The 2023 IT job market has collapsed into a buyer's market with sub‑5% recruiter response rates, soaring candidate competition, higher education filters, and salary stagnation, prompting programmers to lower expectations, sharpen interview skills, and aggressively network for remote or foreign opportunities.
This article explains the concepts of synchronous vs asynchronous and blocking vs non‑blocking I/O, then details the characteristics, advantages, and drawbacks of Java’s three I/O models—BIO, NIO, and AIO—providing guidance on when to use each approach in backend development.
The article explains how TCP connections are identified by a four‑tuple, why the theoretical maximum client connections are 65,535 due to port limits, how servers can theoretically handle up to 2⁴⁸ connections, and why real‑world concurrency is constrained by memory, file descriptors and port reuse rather than the 65535 port count.
This article provides a comprehensive step‑by‑step guide for setting up a new Flutter project, covering network request handling with Dio and protobuf, data persistence using shared_preferences, mmkv and ObjectBox, routing with GoRouter, screen adaptation via flutter_screenutil, splash‑screen configuration, state‑management techniques with Provider and GetX, and detailed explanations of widget lifecycle and key usage.
The curl 7.88.1 update addresses several critical bugs—including HTTP/2 multiplexed data corruption, inaccurate connection timeout handling, uninitialized port values in runtests, missing SRP support checks, HTTP3 fallback when HTTP2 is unavailable, and socketpair EWOULDBLOCK handling—enhancing reliability across platforms.
This article introduces eBPF, explains its origins, compares it with SystemTap and DTrace, outlines its core use cases such as network monitoring, security filtering, performance analysis and virtualization, and provides step‑by‑step examples and tooling for Linux kernel tracing.
This article explains how eBPF extends kernel functionality to enable secure, high‑performance networking, observability, and programmable workloads in cloud‑native environments, detailing its architecture, use cases, market adoption, commercialization models, and the challenges and advantages that make it comparable to JavaScript for the kernel.
This guide explains why a Calico pod shows "BIRD is not ready: BGP not established" in a Kubernetes cluster, identifies the missing node interface detection as the root cause, and provides step‑by‑step instructions to adjust the IP autodetection method and restore pod health.
This article explores Linux kernel TCP connection handling by examining socket data structures, port range and file descriptor tuning, core functions like tcp_v4_rcv, and lookup mechanisms, while offering practical tips to boost client-side concurrent connections beyond traditional limits.
This guide lists six Linux networking commands that have been deprecated—ifconfig, netstat, scp, route, egrep/fgrep, and arp/iptunnel/nameif—and shows the modern ip, ss, sftp/rsync, and grep alternatives with usage examples and brief explanations.
This article explains what eBPF is, why it matters for cloud‑native architectures, its key components and use‑cases in networking, observability and security, and explores current market momentum and commercialization models for leveraging eBPF in modern infrastructure.
This article examines why game companies' servers often avoid microservice architectures, emphasizing the real‑time latency, stateful processing, and networking constraints that make traditional microservice approaches unsuitable for high‑performance game back‑ends and why alternative designs such as custom TCP solutions or stateful server clusters are preferred.
This document provides an extensive overview of computer networking fundamentals, covering basic concepts, OSI layers, link, network, transport, and application layer protocols, addressing schemes, routing algorithms, security mechanisms, and related technologies such as DHCP, DNS, TCP/UDP, MPLS, and wireless LANs.
This article walks through building a minimal Go HTTP server, explains how ListenAndServe manages connections, details the internal accept‑serve loop, shows request handling, routing rules, and customization hooks, providing clear code examples and diagrams to demystify Go’s built‑in web server.
This article explains the essential concepts of TCP and UDP, covering the OSI model layers, socket communication, reliable transmission mechanisms such as stop‑and‑wait and sliding‑window, congestion control, connection establishment, and practical differences between TCP and UDP, providing a comprehensive networking fundamentals overview.
This article explains how TCP/IP functions as a collection of standard components—such as DNS, IP, ARP, TCP, UDP, and TLS—using a step‑by‑step example of a browser accessing zhihu.com, and clarifies each protocol's role, interactions, and quirks.
This article provides concise explanations for over 100 fundamental networking questions, covering topics such as link types, OSI layers, protocols, IP addressing, network devices, topologies, security measures, and configuration tools, offering a quick reference for students and professionals seeking a solid networking foundation.
An in‑depth comparison of HTTP Keep‑Alive (application‑layer persistent connections) and TCP Keepalive (kernel‑level health checks), covering their implementation layers, usage, configuration, timeout handling, and impact on performance, with clear diagrams and code examples to help developers master both mechanisms.
This guide explains how to prevent idle SSH sessions from being terminated by adding a ServerAliveInterval setting to the user‑level or system‑wide SSH configuration files, ensuring the connection stays alive without compromising security.
This article shares practical Linux command techniques—including xargs, background execution, process monitoring, multitail, continuous ping logging, TCP state inspection, and SSH port forwarding—to help system administrators streamline tasks, improve script efficiency, and troubleshoot performance issues.
The article explains how TCP connections are identified by a four‑tuple, clarifies the theoretical maximum of 65,535 client ports versus the far larger possible server connections, and discusses practical limits imposed by memory, file descriptors, and system configuration on Linux servers.
This article introduces eBPF, explains its origins and how it extends BPF for kernel‑level observability, compares it with SystemTap and DTrace, outlines common use cases, details its loading‑compile‑execute workflow, and provides step‑by‑step Python/BCC examples with installation instructions and advanced latency measurement code.
This article explains the concepts of public and private IP addresses, NAT techniques, and the principle of intranet penetration, then demonstrates how to set up and analyze the open‑source FRP framework, including configuration files and core Go code for both server and client components.
This comprehensive guide explains the TCP/IP model’s four layers, key protocols such as IP, ARP, ICMP, DNS, and the differences between TCP and UDP, and details connection setup, termination, flow and congestion control mechanisms like slow start, fast retransmit, and fast recovery.
This article explains how browsers handle TCP connections and SSL sessions when loading pages with many images, covering connection persistence, request multiplexing, HTTP pipelining limitations, per‑host connection limits, and the advantages of HTTP/2 multiplexing for efficient resource fetching.
This article provides a comprehensive overview of IoT protocols and standards, organized by functional layers such as infrastructure, identification, communication, discovery, data exchange, device management, semantics, multi‑layer frameworks, security, and industry verticals, and lists relevant alliances and organizations shaping the IoT ecosystem.
This article explains core components of the Linux kernel network stack, including the sk_buff packet buffer, net_device interfaces for physical and virtual NICs, the relationship between socket and sock structures, layer transitions, Netfilter hooks, and routing via dst_entry, providing a comprehensive overview for developers.
This article explains how MySQL stores NULL values and clarifies the distinct mechanisms of HTTP Keep‑Alive (application‑level long connections) versus TCP Keepalive (kernel‑level health checks), detailing their implementations, usage, and practical considerations.
This comprehensive guide walks through the basics of computer networking, covering OSI and TCP/IP models, network classifications, each layer’s responsibilities, key protocols such as IP, ARP, ICMP, TCP, UDP, and application‑layer services like DNS, DHCP, and HTTP, while illustrating concepts with clear diagrams and practical examples.
This article explains TCP fundamentals—including connection-oriented design, byte‑stream transmission, reliability, header structure, flag meanings, the three‑way handshake, four‑way termination, SYN‑Flood attacks, time‑wait handling, retransmission strategies, kernel tuning parameters, Nagle’s algorithm, and congestion control mechanisms such as slow start and congestion avoidance.
The article surveys the evolution of web communication from HTTP/1.x through HTTPS, HTTP/2, and HTTP/3, explaining request/response structure, methods, status codes, URIs, connection handling, cookies, caching, TLS encryption, and the performance‑boosting features of header compression, multiplexing, and QUIC‑based transport.
This article explains why a trailing dot appears in DNS names, how fully‑qualified domain names (FQDNs) are encoded, the role of zone files and search domains, and when tools like dig, curl, or system resolvers add or omit the dot.
Content Delivery Networks (CDNs) add a caching layer to the Internet, placing content on edge nodes near users to reduce latency, alleviate bandwidth constraints, and improve response speed, with DNS-based smart routing, cache servers, and load balancing forming the core of their operation.
This tutorial walks through building a minimal MVP for the Linkworld iOS app by applying the MVVM pattern, creating a ViewModel, fetching JSON data with URLSession, and adding, editing, and deleting identity cards using SwiftUI state management and context menus.
This article provides a detailed tutorial on Python's urllib library, covering its main modules (request, error, parse, robotparser), key functions and classes, code examples for URL fetching, parsing, encoding, and handling robots.txt, making it a practical resource for backend developers and web scrapers.
The article shows how to transform a single‑threaded Rust STUN server into a high‑performance, multi‑core service by using Linux’s SO_REUSEPORT to bind multiple threads, assigning each to a NIC queue, and employing batch syscalls recvmmsg/sendmmsg, achieving over a million packets per second with significantly lower CPU usage.
This comprehensive Q&A guide covers over one hundred essential networking concepts, including definitions of links, OSI layers, backbone, LAN, nodes, routers, protocols, topologies, security measures, IP addressing, and many other fundamentals needed to understand and manage computer networks.
This article explains the fundamentals of HTTP, how browsers build and send requests, the structure of request and response messages, and the performance improvements introduced by HTTP 2.0 and the QUIC protocol built on UDP.
This article explains the fundamentals of the HTTP protocol, covering request preparation, message structure, methods, headers, caching, the request/response cycle, HTTP/2 enhancements, and the QUIC protocol's advanced features for faster, more reliable web communication.
This comprehensive guide explains the TCP/IP protocol suite, detailing each of its four layers, key protocols such as IP, TCP, UDP, ICMP, ARP, and DNS, and illustrates essential mechanisms like encapsulation, three‑way handshake, flow control, congestion control, and tools like ping and traceroute.
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.
The article explains why MAC addresses are essential by tracing the history and design of the Internet, comparing network protocols to languages, describing the shift from star to mesh topologies for resilience, and showing how TCP/IP relies on underlying layers like Ethernet to function.
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 summarizes a series of technical Q&A from an OSChina event covering Linux networking fundamentals such as port limits, network namespaces, TCP connection handling, C10K problem, packet loss troubleshooting, TCP memory usage, high CPU causes, useful monitoring tools, kernel parameters, and practical socket examples.
This article explains the fundamental networking components of a Kubernetes cluster, detailing the three IP types—NodeIP, PodIP, and ClusterIP—along with how services are exposed using NodePort, LoadBalancer, and Ingress, and provides practical guidance on configuring cloud‑native load balancers and Ingress controllers.
This article explains the TCP keepalive mechanism, its purpose, default parameters, how to configure and verify it on Linux, its drawbacks, and the distinction between TCP keepalive and HTTP Keep-Alive, providing practical code examples and network analysis steps.
This article provides a comprehensive overview of NVIDIA's DOCA framework, BlueField DPU architecture, SDK components, programming models, and related technologies such as RDMA, RoCE, and GPUDirect RDMA, highlighting their roles in modern data‑center acceleration and security.
This article provides a comprehensive guide to diagnosing and fixing a wide range of Docker problems, including storage migration, disk space shortages, missing libraries, container corruption, network configuration, permission errors, image management, and timeout issues, with detailed command-line solutions and configuration examples.
In high‑concurrency scenarios, massive TIME_WAIT TCP connections can exhaust local ports, causing new connections to fail, but by understanding the TCP four‑handshake, adjusting socket reuse settings, and using keep‑alive, you can mitigate the issue.
This article provides a concise overview of Kubernetes architecture—including the master, nodes, and etcd—explains how deployments create replica sets and pods, describes pod fundamentals, container orchestration features, networking basics, and the role of services for microservice discovery and external access.
This article explains the fundamentals of TCP, why raw TCP lacks message boundaries, how HTTP and RPC are built on top of TCP, and the practical reasons why both protocols coexist in modern software architectures.
This article provides a comprehensive overview of TCP and UDP, explaining their roles in the transport layer, key differences in reliability and speed, the three‑way handshake and four‑way termination processes of TCP, and how data transmission is handled by both protocols.
This article provides a comprehensive overview of Kubernetes, explaining its master‑node architecture, key components such as API Server, Scheduler, Controller, kubelet and kube‑proxy, the lifecycle of a Deployment, Pod design, Service discovery, networking models, and external access methods.
This article explains the fundamental differences between TCP and UDP, covering their purposes, reliability, speed, handshake mechanisms, data transmission processes, and termination procedures, and includes visual diagrams to illustrate each concept in.
This article provides a comprehensive overview of Kubernetes, covering its master‑node architecture, core components such as API Server, Scheduler, and Controllers, the step‑by‑step creation of Deployments, the role of Pods, container orchestration patterns, networking fundamentals, and service discovery mechanisms for microservices.
The article thoroughly examines Asio’s core mechanisms—its scheduler’s post handling, the strand’s lock‑based ordering, and the timer subsystem’s heap‑driven queues—detailing executor operations, multi‑threaded execution paths, platform‑specific timer schedulers, and the efficient C++ techniques that enable high‑performance asynchronous programming.
This article explains the fundamentals of TCP sockets, why raw TCP lacks message boundaries, how custom protocols add headers to solve the sticky‑packet problem, and compares HTTP and RPC as application‑layer protocols, highlighting their histories, use‑cases, and performance trade‑offs.
This tutorial explains how to programmatically log into a campus network by analyzing HTTP requests, crafting POST data, retrieving the local IP address, automating Wi‑Fi connection on macOS using pywifi, and finally packaging the script into a standalone executable with pyinstaller.
This article provides a comprehensive overview of Kubernetes, covering its master‑node architecture, core components like API server, scheduler, controller, kubelet and kube‑proxy, the deployment creation process, pod fundamentals, service networking, and common patterns such as scaling, rolling updates, and ingress access.
This article provides a concise overview of Kubernetes, explaining its master‑node architecture, describing key components such as API server, scheduler, controller, kubelet and kube‑proxy, and detailing how deployments, pods, services, networking, scaling, updates and ingress work together to orchestrate containerized applications.
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 comprehensive guide explains Kubernetes' networking model, covering core concepts, pod-to-pod communication, service routing, DNS integration, and external traffic handling, while detailing the underlying Linux network namespaces, virtual Ethernet pairs, bridges, and CNI plugins.
Netty 5.0.0.Alpha4 has been released, removing duplicated code, cleaning up the API, adding ProtocolFamily‑based socket creation, renaming options, supporting JDK Unix Domain Sockets, improving EventLoop registration, fixing macOS disconnect, and replacing synchronized blocks with Java Locks for better Loom compatibility.
This article explains the fundamentals of Kubernetes Service, walks through a real‑world failure case, details how to configure different Service types (ClusterIP, NodePort, LoadBalancer, ExternalName, Headless), and explores the underlying implementation mechanisms such as user‑space proxy, iptables, and IPVS.
This article uses vivid school analogies and detailed diagrams to explain how computers communicate over networks, covering concepts such as hosts, subnets, IP and MAC addresses, subnet masks, ARP, DHCP, routing, and NAT, helping readers grasp both basic and advanced networking principles.
This article provides a comprehensive overview of TCP and UDP, explaining their roles in the transport layer, key differences such as connection orientation and reliability, the three‑way handshake and four‑way termination processes of TCP, and the typical use cases and limitations of each protocol.
This article demonstrates how to build a Netty‑based WebSocket server integrated with Spring Boot, covering Maven dependencies, server initialization, channel handlers, a simple HTML client, and extending the handler to parse URL query parameters for custom communication.
This comprehensive guide explains the Kubernetes networking model, covering core concepts such as the API server, controllers, pods, nodes, and the layered network architecture, then walks through pod‑to‑pod, pod‑to‑service, and external traffic flows using CNI plugins, iptables, IPVS, bridges, and ingress controllers.
This tutorial explains how to obtain a user's IP address from an HttpServletRequest, interpret the IP using the ip2region offline database, and display the corresponding province or country in a Java backend application, including code examples and Maven integration.
A recent Hacker News discussion revealed that Docker’s iptables rule allows containers bound to 127.0.0.1 to be reachable from other hosts, and a step‑by‑step proof‑of‑concept demonstrates the issue while a revised iptables rule is proposed to enforce proper source‑address restrictions.
This article explains the concept of Power over Ethernet (PoE), why it is needed, its advantages, the roles of power‑sourcing and powered devices, power delivery modes, negotiation processes, IEEE standards (802.3af/at/bt), and the types of equipment that can support PoE.
This article analyses the rapid evolution of cloud‑native networking, identifies key challenges across traditional, data‑center, edge, multi‑cluster, financial, and telecom scenarios, and presents open‑source and commercial solutions such as Kube‑OVN, Underlay networks, flexible IPAM, and hardware‑software acceleration.
