# round robin

Published articles for round robin.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Understanding Load Balancing for Beginners

DevFeed: [Understanding Load Balancing for Beginners](<https://devfeed.tech/articles/understanding-load-balancing-for-beginners-17489.md>)

Original publisher: [Read original article](<https://kodekloud.com/blog/understanding-load-balancing-for-beginners/>)

Author: Pramodh Kumar M

Published: 2026-08-17T17:00:34Z

Content type: tutorial

Language: en

Sources: [Kubernetes - KodeKloud Blog | DevOps, Cloud, Kubernetes, AI Tutorials & More](<https://devfeed.tech/sources/kubernetes-kodekloud-blog-devops-cloud-kubernetes-ai-tutorials-more.md>)

Topics: [backends](<https://devfeed.tech/topics/backends.md>), [networking](<https://devfeed.tech/topics/networking.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [beginners](<https://devfeed.tech/tags/beginners.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [connection-draining](<https://devfeed.tech/tags/connection-draining.md>), [devops](<https://devfeed.tech/tags/devops.md>), [failover](<https://devfeed.tech/tags/failover.md>), [health-checks](<https://devfeed.tech/tags/health-checks.md>), [high-availability](<https://devfeed.tech/tags/high-availability.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [layer-4-vs-layer-7](<https://devfeed.tech/tags/layer-4-vs-layer-7.md>), [least-connections](<https://devfeed.tech/tags/least-connections.md>), [load-balancer](<https://devfeed.tech/tags/load-balancer.md>), [load-balancer-for-beginners](<https://devfeed.tech/tags/load-balancer-for-beginners.md>), [load-balancing](<https://devfeed.tech/tags/load-balancing.md>), [load-balancing-algorithms](<https://devfeed.tech/tags/load-balancing-algorithms.md>), [networking](<https://devfeed.tech/tags/networking.md>), [nginx](<https://devfeed.tech/tags/nginx.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [session-affinity](<https://devfeed.tech/tags/session-affinity.md>), [sre](<https://devfeed.tech/tags/sre.md>), [sticky-sessions](<https://devfeed.tech/tags/sticky-sessions.md>), [thundering-herd](<https://devfeed.tech/tags/thundering-herd.md>), [traffic-management](<https://devfeed.tech/tags/traffic-management.md>)

### AI overview

This beginner-oriented article explains load balancing as both traffic distribution and backend failure detection. It compares round robin and least-connections algorithms, distinguishes Layer 4 from Layer 7 routing, and discusses health checks, failover, draining, sticky sessions, and the risks of overly aggressive checks.

### Source excerpt

Spreading traffic is the easy half of load balancing. The half that decides whether an outage lasts ten seconds or ten minutes is noticing that a backend has stopped working, and most health checks cannot.

## pproxy: a forward proxy that load-balances a pool of upstream proxies

DevFeed: [pproxy: a forward proxy that load-balances a pool of upstream proxies](<https://devfeed.tech/articles/pproxy-a-forward-proxy-that-load-balances-a-pool-of-upstream-proxies-34032.md>)

Original publisher: [Read original article](<https://andikaahmad.com/blog/pproxy/>)

Published: 2026-06-22T00:00:00Z

Content type: article

Language: en

Sources: [Andika Ahmad Ramadhan -- Blog](<https://devfeed.tech/sources/andika-ahmad-ramadhan-blog.md>)

Topics: [proxy](<https://devfeed.tech/topics/proxy.md>), [client](<https://devfeed.tech/topics/client.md>), [health checks](<https://devfeed.tech/topics/health-checks.md>), [HTTP](<https://devfeed.tech/topics/http.md>)

Tags: [client](<https://devfeed.tech/tags/client.md>), [health](<https://devfeed.tech/tags/health.md>), [health-checks](<https://devfeed.tech/tags/health-checks.md>), [http](<https://devfeed.tech/tags/http.md>), [prometheus](<https://devfeed.tech/tags/prometheus.md>), [proxy](<https://devfeed.tech/tags/proxy.md>), [reload](<https://devfeed.tech/tags/reload.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [socks5](<https://devfeed.tech/tags/socks5.md>), [tls](<https://devfeed.tech/tags/tls.md>)

### AI overview

This article presents pproxy, a forward proxy that distributes client traffic across upstream proxies. It describes active health checks, round-robin selection, failover within requests, hot configuration reloads, per-user authentication, and Prometheus metrics.

### Source excerpt

pproxy is a forward proxy that load-balances client traffic across a pool of upstream proxies with active health checks and hot config reload, so switching proxy providers means editing one config file instead of every client.

## Working Effectively with Claude Code

DevFeed: [Working Effectively with Claude Code](<https://devfeed.tech/articles/working-effectively-with-claude-code-33580.md>)

Original publisher: [Read original article](<https://blog.scottlogic.com/2026/06/18/working-effectively-with-claude-code.html>)

Author: Amy Laws

Published: 2026-06-18T09:09:00Z

Content type: article

Language: en

Sources: [Scott Logic](<https://devfeed.tech/sources/scott-logic.md>)

Topics: [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [parallel](<https://devfeed.tech/topics/parallel.md>), [Terminal](<https://devfeed.tech/topics/terminal.md>), [Code](<https://devfeed.tech/topics/code.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Git](<https://devfeed.tech/topics/git.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [github-copilot](<https://devfeed.tech/tags/github-copilot.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [terminal](<https://devfeed.tech/tags/terminal.md>), [vs-code](<https://devfeed.tech/tags/vs-code.md>)

### AI overview

This article shares practical lessons from switching from GitHub Copilot in VS Code to Claude Code. It focuses on parallel development with multiple agents, using terminal sessions and Git worktrees, and managing concurrent work through Claude Code's agent view.

### Source excerpt

After months working with GitHub Copilot in VS Code and recently switching to Claude Code, the transition turned out to be more involved than expected. Claude Code operates differently and in ways that take time to adjust to. In this post, I share my experiences and tips drawn from that experience.

## Load Balancing and Scaling LLM Serving

DevFeed: [Load Balancing and Scaling LLM Serving](<https://devfeed.tech/articles/load-balancing-and-scaling-llm-serving-19903.md>)

Original publisher: [Read original article](<https://www.digitalocean.com/blog/load-balancing-scaling-llm-serving>)

Author: Mohammad Ashar Khan

Published: 2026-04-15T19:03:31Z

Content type: article

Language: en

Sources: [DigitalOcean](<https://devfeed.tech/sources/digitalocean.md>)

Topics: [Load Balancing](<https://devfeed.tech/topics/load-balancing.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Routing (disambiguation)](<https://devfeed.tech/topics/routing.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [sglang](<https://devfeed.tech/topics/sglang.md>), [vllm](<https://devfeed.tech/topics/vllm.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [TensorRT](<https://devfeed.tech/topics/tensorrt.md>)

Tags: [caching](<https://devfeed.tech/tags/caching.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [http](<https://devfeed.tech/tags/http.md>), [inference](<https://devfeed.tech/tags/inference.md>), [latency](<https://devfeed.tech/tags/latency.md>), [llm](<https://devfeed.tech/tags/llm.md>), [load-balancing](<https://devfeed.tech/tags/load-balancing.md>), [performance](<https://devfeed.tech/tags/performance.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [sglang](<https://devfeed.tech/tags/sglang.md>), [tensorrt](<https://devfeed.tech/tags/tensorrt.md>), [vllm](<https://devfeed.tech/tags/vllm.md>)

### AI overview

This article explains why scaling LLM serving requires load-balancing strategies that account for prompt-prefix caching. It describes how naive round-robin routing reduces cache-hit probability as the number of replicas grows, and introduces cache-aware routing approaches intended to preserve cache efficiency, control costs, and improve performance. It also discusses inference engines including vLLM, SGLang, and TensorRT, along with prefill and decode processing.

### Source excerpt

Load balancing for LLMs is fundamentally different from load balancing for traditional services like web servers, APIs, or databases. Prompt caching is the reason. Prompt caching typically cuts input token costs by 50-90% and can reduce Time to First Token (TTFT) latency by up to 80%, but those gains assume your request lands on the replica that already has the relevant prefix cached. Under naive round-robin load balancing across N replicas, that probability is 1/N. The cache hit rate that made caching so attractive at one replica degrades almost linearly as your fleet grows. Solving this requires rethinking how requests are routed at the infrastructure level. This article covers the load balancing strategies and specialized routers that preserve cache efficiency at scale, starting with why standard approaches fall short and progressing to precise, cache-aware routing techniques. Inferencing engines To achieve large-scale inferencing, we use inference engines. These engines simplify the complexities of serving LLMs and offer improved resource utilization on the underlying GPUs. They also enable higher concurrency and allow for customization to suit diverse inference workloads, such as real-time chat completions and long-form document summarization. Noteworthy engine options include vLLM, SGLang, and TensorRT. The inferencing process is largely consistent across different engines. Sending an HTTP request to an engine initiates a standard sequence of steps. Prefill Phase: The input prompt is first converted into token IDs using the model's tokenizer. Requests are grouped into batches for efficient concurrent processing by the engine. During this initial processing, special Key (K) and Value (V) tensors are computed. This phase concludes after the first forward pass, resulting in the generation of the first output token. Decode Phase: This phase involves an auto-regressive loop, continuing until an end-of-sequence token is generated or the maximum sequence length is re

## Advanced Prompt Caching at Scale

DevFeed: [Advanced Prompt Caching at Scale](<https://devfeed.tech/articles/advanced-prompt-caching-at-scale-19856.md>)

Original publisher: [Read original article](<https://www.digitalocean.com/blog/advanced-prompt-caching>)

Author: Andrew Dugan

Published: 2026-04-07T19:11:40Z

Content type: tutorial

Language: en

Sources: [DigitalOcean](<https://devfeed.tech/sources/digitalocean.md>)

Topics: [Caching](<https://devfeed.tech/topics/caching.md>), [Inference Performance](<https://devfeed.tech/topics/inference-performance.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Inference](<https://devfeed.tech/topics/inference.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Load Balancing](<https://devfeed.tech/topics/load-balancing.md>), [round robin](<https://devfeed.tech/topics/round-robin.md>), [sglang](<https://devfeed.tech/topics/sglang.md>), [TensorRT-LLM](<https://devfeed.tech/topics/tensorrt-llm.md>), [vllm](<https://devfeed.tech/topics/vllm.md>), [model architecture](<https://devfeed.tech/topics/model-architecture.md>)

Tags: [ai-ml](<https://devfeed.tech/tags/ai-ml.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [caching](<https://devfeed.tech/tags/caching.md>), [decoding](<https://devfeed.tech/tags/decoding.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [inference](<https://devfeed.tech/tags/inference.md>), [latency](<https://devfeed.tech/tags/latency.md>), [llm](<https://devfeed.tech/tags/llm.md>), [load-balancing](<https://devfeed.tech/tags/load-balancing.md>), [prompt](<https://devfeed.tech/tags/prompt.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [sglang](<https://devfeed.tech/tags/sglang.md>), [tensorrt-llm](<https://devfeed.tech/tags/tensorrt-llm.md>), [token](<https://devfeed.tech/tags/token.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [vllm](<https://devfeed.tech/tags/vllm.md>)

### AI overview

This tutorial explains how prompt caching works across multiple LLM replicas. It describes how round-robin load balancing reduces cache-hit rates and presents session affinity, tiered routing, and prefix-aware load balancing as architectural strategies for preserving KV-cache reuse while reducing latency and inference costs.

### Source excerpt

Introduction Prompt caching is the process of reusing already computed KV states across inference requests in order to save money and reduce latency. Within a single replica, modern inference engines like vLLM, SGLang, and TensorRT-LLM handle it automatically. Incoming prompts are matched against cached prefixes and recomputed only where necessary, without requiring user configurations The problem nobody talks about is what happens when you scale to many replicas. Under round-robin load balancing, a request with an identical prefix has only a 1/N chance of hitting the replica where that prefix is already cached. The cache hit rate that made prompt caching so attractive at one replica degrades almost linearly as your fleet grows, unless you architect around it deliberately. Done right, prompt caching at scale offers 50-90% discounts on cached input tokens and can reduce time-to-first-token (TTFT) latency by up to 80%. This article covers the architectural strategies that make that possible. The Single-Replica Ceiling Refer to our previous prompt caching article for a detailed explanation of how KV caching works under the hood. Every transformer-based LLM uses KV caching to store key and value vectors from the attention layers in GPU VRAM during decoding. This intra-request caching is baked into the model architecture to increase throughput and maximize efficiency. Within a single replica, modern open-source engines like vLLM, SGLang (via RadixAttention), and TensorRT-LLM support automatic prefix caching out of the box, matching incoming prompts against previously cached prefixes to maximize KV reuse without any user configuration. Reusing KV states across requests from many users and replicas is where inference frameworks differ significantly. In the simplest architecture, the cache lives on individual replicas in VRAM. It is not shared across model instances at all. When a user makes an inference request, the prompt from their request is cached on a single replica.

## How Agoda Load Balanced Kafka

DevFeed: [How Agoda Load Balanced Kafka](<https://devfeed.tech/articles/how-agoda-load-balanced-kafka-34677.md>)

Original publisher: [Read original article](<https://newsletter.systemdesigncodex.com/p/how-agoda-load-balanced-kafka>)

Author: Saurabh Dashora

Published: 2026-03-10T08:01:37Z

Content type: article

Language: en

Sources: [System Design Codex](<https://devfeed.tech/sources/system-design-codex.md>)

Topics: [Kafka](<https://devfeed.tech/topics/kafka.md>), [data-processing](<https://devfeed.tech/topics/data-processing.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [data-centers](<https://devfeed.tech/tags/data-centers.md>), [data-processing](<https://devfeed.tech/tags/data-processing.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [partitioning](<https://devfeed.tech/tags/partitioning.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>)

### AI overview

A deep dive into how Agoda uses Kafka to process large volumes of real-time supplier price updates. It explains the distributor, processor, and Kafka components, then examines how partitions, partitioners, and consumer assignors support parallel processing and expose challenges when workloads and consumer capabilities are uneven.

### Source excerpt

Deep Dive

## Data API Routes to Nearest Read Replica

DevFeed: [Data API Routes to Nearest Read Replica](<https://devfeed.tech/articles/data-api-routes-to-nearest-read-replica-352.md>)

Original publisher: [Read original article](<https://supabase.com/blog/data-api-nearest-read-replica>)

Author: José Ledesma

Published: 2025-04-04T07:00:00Z

Content type: article

Language: en

Sources: [Supabase Blog](<https://devfeed.tech/sources/supabase-blog.md>)

Topics: [API](<https://devfeed.tech/topics/api.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Database](<https://devfeed.tech/topics/database.md>), [Algorithms, Complexity](<https://devfeed.tech/topics/algorithms-complexity.md>), [networking](<https://devfeed.tech/topics/networking.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [api](<https://devfeed.tech/tags/api.md>), [data](<https://devfeed.tech/tags/data.md>), [geospatial](<https://devfeed.tech/tags/geospatial.md>), [latency](<https://devfeed.tech/tags/latency.md>), [load-balancer](<https://devfeed.tech/tags/load-balancer.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [network](<https://devfeed.tech/tags/network.md>), [read-replica](<https://devfeed.tech/tags/read-replica.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>)

### AI overview

Supabase is releasing geo-routing for Data API requests, directing each request to the geographically nearest read replica. The feature uses network-edge geolocation, regional coordinate mapping, distance calculations with the Haversine formula, and round-robin distribution when multiple databases share a region. It is available by default through a load balancer endpoint and requires only a project URL update.

### Source excerpt

Route your Data API (PostgREST) requests to the nearest Read Replica

## Why Dropbox Built the Robinhood Load Balancer

DevFeed: [Why Dropbox Built the Robinhood Load Balancer](<https://devfeed.tech/articles/how-dropbox-saved-millions-of-dollars-by-building-a-load-balancer-17971.md>)

Original publisher: [Read original article](<https://newsletter.betterstack.com/p/how-dropbox-saved-millions-of-dollars>)

Author: Richard Oliver Bray

Published: 2024-12-11T14:01:03Z

Content type: article

Language: en

Sources: [Hacking Scale by Better Stack](<https://devfeed.tech/sources/hacking-scale-by-better-stack.md>)

Topics: [Cloud](<https://devfeed.tech/topics/cloud.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>), [servers](<https://devfeed.tech/topics/servers.md>), [real-time](<https://devfeed.tech/topics/real-time.md>)

Tags: [cloud](<https://devfeed.tech/tags/cloud.md>), [dropbox](<https://devfeed.tech/tags/dropbox.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [load-balancing](<https://devfeed.tech/tags/load-balancing.md>), [network](<https://devfeed.tech/tags/network.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [server](<https://devfeed.tech/tags/server.md>), [servers](<https://devfeed.tech/tags/servers.md>)

### AI overview

The article explains how Dropbox handled overloaded virtual servers with different hardware capabilities. Its traditional fixed-weight round-robin approach could not distribute load evenly, so the team built Robinhood, a dynamic weighted round-robin load balancer with gRPC support.

### Source excerpt

Dropbox saved resources by creating a superior version of a tool everyone uses

## Load balancing and scaling long-lived connections in Kubernetes

DevFeed: [Load balancing and scaling long-lived connections in Kubernetes](<https://devfeed.tech/articles/load-balancing-and-scaling-long-lived-connections-in-kubernetes-19137.md>)

Original publisher: [Read original article](<https://learnkube.com/kubernetes-long-lived-connections>)

Author: Daniele Polencic

Published: 2024-06-10T00:00:00Z

Content type: tutorial

Language: en

Sources: [Learnk8s](<https://devfeed.tech/sources/learnk8s.md>)

Topics: [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Load Balancing](<https://devfeed.tech/topics/load-balancing.md>), [gRPC](<https://devfeed.tech/topics/grpc.md>), [client](<https://devfeed.tech/topics/client.md>), [HTTP](<https://devfeed.tech/topics/http.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [http](<https://devfeed.tech/tags/http.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [kubernetes-services](<https://devfeed.tech/tags/kubernetes-services.md>), [load-balancer](<https://devfeed.tech/tags/load-balancer.md>), [load-balancing](<https://devfeed.tech/tags/load-balancing.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>)

### AI overview

This tutorial explains why Kubernetes Services may not evenly distribute requests over long-lived connections. It describes Kubernetes Services and Deployments and discusses client-side load balancing or proxies for HTTP/2, gRPC, RSocket, AMQP, and long-lived database connections.

### Source excerpt

Handle long-lived connections in Kubernetes. Master client-side load balancing for HTTP/2, gRPC, and database connections.

## Customer Invisible Maintenance of the CSC Object Storage Servers

DevFeed: [Customer Invisible Maintenance of the CSC Object Storage Servers](<https://devfeed.tech/articles/customer-invisible-maintenance-of-the-csc-object-storage-servers-19761.md>)

Original publisher: [Read original article](<https://cloud.blog.csc.fi/2018/03/customer-invisible-maintenance-of-csc.html>)

Author: Unknown (noreply@blogger.com)

Published: 2018-03-14T07:36:00Z

Content type: article

Language: en

Sources: [CSC - IT Center For Science - Cloud Team](<https://devfeed.tech/sources/csc-it-center-for-science-cloud-team.md>)

Topics: [BGP](<https://devfeed.tech/topics/bgp.md>), [networking](<https://devfeed.tech/topics/networking.md>), [Load Balancing](<https://devfeed.tech/topics/load-balancing.md>), [Availability](<https://devfeed.tech/topics/availability.md>), [round robin](<https://devfeed.tech/topics/round-robin.md>)

Tags: [bgp](<https://devfeed.tech/tags/bgp.md>), [ceph](<https://devfeed.tech/tags/ceph.md>), [cpouta](<https://devfeed.tech/tags/cpouta.md>), [dns](<https://devfeed.tech/tags/dns.md>), [exabgp](<https://devfeed.tech/tags/exabgp.md>), [failover](<https://devfeed.tech/tags/failover.md>), [ha](<https://devfeed.tech/tags/ha.md>), [high-availability](<https://devfeed.tech/tags/high-availability.md>), [load-balancing](<https://devfeed.tech/tags/load-balancing.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [network](<https://devfeed.tech/tags/network.md>), [networking](<https://devfeed.tech/tags/networking.md>), [object-storage](<https://devfeed.tech/tags/object-storage.md>), [radosgw](<https://devfeed.tech/tags/radosgw.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [routing](<https://devfeed.tech/tags/routing.md>), [server](<https://devfeed.tech/tags/server.md>)

### AI overview

The CSC Pouta Cloud Team describes using ExaBGP on object storage servers to combine round-robin DNS load balancing with BGP routing for high availability and failover during maintenance.

### Source excerpt

Hello! It's the CSC Pouta Cloud Team again! You may recognize us from other object storage films such as: http://pouta.blog.csc.fi/2018/02/admin-stories-implement-object-storage.html where we go through in excruciating detail how we configured CEPH RadosGW and why we configured it like we did http://pouta.blog.csc.fi/2018/01/objectively-speaking-in-cpouta.html where we announced object storage! In this episode we're going to talk a bit about how we implemented invisible(*) maintenance for our Object Storage customers. Configuration of ExaBGP with Object Storage CSC - IT Center for Science Ltd. has a close collaboration with the Finnish University and Research Network - FUNET, and because of that we are in a great position to do some fun network stuff. Actually, as long as your network has a BGP relationship with its internet provider you can also do what we have done. When we first launched Object Storage we just had a DNS entry pointing to two IP addresses. This gave us some load balancing and if we really wanted to we could take a node out of the DNS and do maintenance. But we wanted more! *ExaBGP enters the stage* In short we installed ExaBGP on our object storage linux servers, configured one dummy network interface per server and started to announce two IP addresses from each server. Then we pointed object.pouta.csc.fi DNS entry to these two IP addresses. The objective was to use round-robin DNS for load-balancing and BGP routing for High Availability. For failover this means that if one node goes down, the other IP is reachable on the other node and stuff will keep magically(*) working! There are some other BGP softwares out there, like BIRD or Quagga. Despite this, we never actually tried any other software since ExaBG has some great qualities such as: it came recommended by the network team at CSC who uses it for some services its low resource footprint and small number of software dependencies it is not a full routing suite - it is meant to be used for basi

## Parallel pgloader

DevFeed: [Parallel pgloader](<https://devfeed.tech/articles/parallel-pgloader-34439.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2011/08/parallel-pgloader/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2011-08-01T10:15:00Z

Content type: tutorial

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [parallel](<https://devfeed.tech/topics/parallel.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Processes](<https://devfeed.tech/topics/processes.md>), [Python](<https://devfeed.tech/topics/python.md>), [round robin](<https://devfeed.tech/topics/round-robin.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [benefit](<https://devfeed.tech/tags/benefit.md>), [code](<https://devfeed.tech/tags/code.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [process](<https://devfeed.tech/tags/process.md>), [python](<https://devfeed.tech/tags/python.md>), [queues](<https://devfeed.tech/tags/queues.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [threading](<https://devfeed.tech/tags/threading.md>)

### AI overview

This tutorial explains how pgloader loads data in parallel. It describes loading multiple files concurrently, splitting large files among workers, and using a reader thread with worker threads and queues. It also cautions that Python's Global Interpreter Lock limits runtime parallelism and recommends testing thread configurations.

### Source excerpt

This article continues the series that began with How To Use PgLoader then detailed How to Setup pgloader. We have some more fine points to talk about here, today's article is about loading your data in parallel with pgloader.