Horizontal scaling
Horizontal scaling is adjusting system capacity by adding or removing computing nodes or equivalent instances that share or distribute the workload.
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
Horizontal scaling is increasing or decreasing system capacity by adding or removing equivalent computing instances.
- How it is used
- Uses horizontal scaling to handle changing EC2 workloads and increase database read and write capacity.
- How deep it goes
- Defines scaling through instance counts and database nodes, then outlines architectural requirements and capacity modes without providing configuration commands.
- Examples
- Illustrates spiky demand with web-application error tracking and a business-hours batch job that briefly raises database throughput.
- What you can do after
- Evaluate/understand it by identifying prerequisites for a dynamic EC2 pool and comparing DynamoDB capacity modes against demand.
MongoDB 8.0 in Action, Third Edition
Horizontal scaling is the practice of increasing capacity by distributing workloads across additional machines or partitions.
- How it is used
- Positions horizontal scaling as MongoDB’s way to accommodate growing datasets and high transaction rates by distributing data and workload.
- How deep it goes
- Explains sharding at collection and cluster level, including trade-offs, but provides no shard-creation commands in the supplied passages.
- Examples
- Uses RAM and disk capacity limits, a sharded-cluster diagram, and Atlas autoscaling behavior as concrete reference points.
- What you can do after
- Evaluate/understand when sharding addresses capacity or write bottlenecks, and why replication or Atlas tier autoscaling is not a substitute.
Read how MongoDB 8.0 in Action, Third Edition explains horizontal scaling →
Elasticsearch in Action, Second Edition
Horizontal scaling increases system capacity by adding more nodes or machines rather than increasing the resources of an existing node.
- How it is used
- Increases Elasticsearch capacity for growing data, query loads, read throughput, or indexing performance by adding cluster nodes.
- How deep it goes
- Explains node addition, cluster membership, capacity planning, and a 10 TB example, but defers detailed shard-sizing treatment.
- Examples
- Uses a 25-node, 10 TB multi-index cluster and compares adding 20 nodes with enlarging five existing servers.
- What you can do after
- Operate/configure an Elasticsearch cluster by adding nodes and forecasting capacity for data, memory, throughput, and indexing demands.
Read how Elasticsearch in Action, Second Edition explains horizontal scaling →
Distributed Machine Learning Patterns
A scaling technique that increases capacity by adding equivalent service instances or machines rather than enlarging one instance.
- How it is used
- Handles growing model-serving traffic by deploying replicated services.
- How deep it goes
- Explains statelessness, replica placement, asynchronous processing, and load distribution, but omits detailed implementation configuration.
- Examples
- Uses video-upload inference, replicated model servers, separate server addresses, and a load-balancer diagram.
- What you can do after
- Apply it via replicated model-serving services to handle more requests asynchronously.
Read how Distributed Machine Learning Patterns explains horizontal scaling →
Building Web APIs with ASP.NET Core
Horizontal scaling increases capacity by adding or removing service instances rather than enlarging one instance.
- How it is used
- Compares database scaling strategies when choosing between SQL and NoSQL storage.
- How deep it goes
- Defines scale-out through clusters, workload sharing, and node changes, while stopping short of implementation details.
- Examples
- Uses multiple database servers forming a cluster and adding or removing nodes to accommodate workload requirements.
- What you can do after
- Evaluate database architectures by comparing scale-out, scale-up, workload distribution, availability, and operational trade-offs.
Read how Building Web APIs with ASP.NET Core explains horizontal scaling →
ScyllaDB in Action
Cluster scaling is the operation of increasing a cluster's capacity by adding nodes while retaining its existing nodes.
- How it is used
- Expands ScyllaDB capacity when application demand exceeds the current cluster’s resources.
- How deep it goes
- Defines node-based expansion and gives a procedural scale-up checklist, including readiness, rack balance, and cleanup.
- Examples
- Uses added cluster nodes, nodetool status, rack balancing, and nodetool cleanup as operational examples.
- What you can do after
- Operate/configure a ScyllaDB scale-up by adding nodes sequentially, checking readiness, balancing racks, and cleaning transferred data.
Refactoring to Rust
Horizontal scaling is increasing service capacity by running additional instances of a system.
- How it is used
- Uses additional service instances to address throughput bottlenecks without adding resources to one machine.
- How deep it goes
- Defines horizontal scaling, contrasts vertical scaling, and demonstrates process duplication before addressing distributed-service code changes.
- Examples
- Demonstrates concurrent Python processes producing the same `single.png` output and overwriting one another.
- What you can do after
- Diagnoses why duplicated service instances can collide on outputs even when the underlying computation is idempotent.
Microsoft Azure in Action
A scaling technique that adds or removes database or virtual-machine instances to change aggregate computing capacity.
- How it is used
- Distributes changing application or database workload across additional instances instead of enlarging one instance.
- How deep it goes
- Defines scaling out, contrasts vertical scaling, and explains VM pools, read replicas, autoscaling, and workload routing.
- Examples
- Uses VM pools, Azure SQL read replicas, and Banning Books peak-sale traffic as concrete examples.
- What you can do after
- Operate elastic compute or database capacity by adding instances, routing suitable reads, and removing capacity as demand falls.
Read how Microsoft Azure in Action explains horizontal scaling →
Kubernetes in Action, Second Edition
Scaling out is increasing application capacity by running additional application instances.
- How it is used
- Scales a deployed application when one instance cannot handle increased user load.
- How deep it goes
- Explains replica changes and desired-state reconciliation, then demonstrates resulting Pods and Service traffic.
- Examples
- Uses kubectl scale, Deployment status, Pod listings, and repeated curl requests to show distribution.
- What you can do after
- Apply it via kubectl by setting a Deployment's desired replica count and checking available Pods.
Read how Kubernetes in Action, Second Edition explains horizontal scaling →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
Horizontal scaling is the technique of increasing capacity by running multiple instances of a component and distributing its workload among them.
- How it is used
- Uses microservices and Kubernetes to increase capacity, relieve bottlenecks, and support higher workloads.
- How deep it goes
- Explains cluster, service, elastic, and database implications with Terraform and Kubernetes examples, but defers advanced autoscaler customization.
- Examples
- Demonstrates six smaller VMs, three gateway replicas, Kubernetes monitoring, and Terraform autoscaling bounds.
- What you can do after
- Operate/configure cluster and service capacity through Terraform node counts, Kubernetes replicas, and autoscaling limits.
Fast Python: High performance techniques for large datasets
- How it is used
- Uses Dask to distribute computation when data or computational demands exceed a single computer’s capacity.
- How deep it goes
- Defines scale-out and contrasts it with scale-up, then identifies Dask’s scheduler and larger-than-memory data as central topics.
- Examples
- Uses Mandelbrot image generation to exercise Dask’s array interface and compares pure Python with Cython or Numba implementations.
- What you can do after
- Operate Dask’s distributed scheduler locally or schedule tasks across machines using cluster, SSH, or cloud implementations.
Read how Fast Python: High performance techniques for large datasets explains horizontal scaling →
Build AI-Enhanced Web Apps
Horizontal scaling is the addition or removal of application instances to change processing capacity.
- How it is used
- Supports deployment planning by matching application capacity and operational safeguards to expected traffic.
- How deep it goes
- Defines adding instances and places the practice in a tiered checklist without detailing implementation mechanics.
- Examples
- Uses applications below 10,000 requests per day as the concrete simple-scaling scenario.
- What you can do after
- Operate/configure capacity by planning simple instance expansion for increased application load.
Read how Build AI-Enhanced Web Apps explains horizontal scaling →
Grokking Concurrency
A scaling approach that increases performance by distributing load across existing and additional processing resources.
- How it is used
- Improves program and system performance by distributing load across existing and additional processing resources.
- How deep it goes
- Explains the definition, contrasts scaling up, and extends the idea to concurrency and computing clusters without implementation details.
- Examples
- Uses existing and new processing resources, interconnected machines, computing clusters, real-time systems, and high-volume data as examples.
- What you can do after
- Apply the approach by distributing load across existing and new processing resources, including interconnected machines in a computing cluster.
Related concepts
- vertical scalingalternative to · Vertical scaling is increasing or decreasing a system’s capacity by changing the resources available to an existing machine, node, or instance.
- replicauses · A replica is a copy of data or state, or an equivalent running instance of a component, maintained alongside others in a replicated system.
- scalabilitykind of · Scalability is the ability of a system, process, or method to accommodate increasing workload, size, or demand while maintaining acceptable operation.
- load balancinguses · Load balancing is the distribution of requests or computational work across multiple resources to manage demand, reduce workload imbalance, and improve utilization or availability.
- autoscalingkind of · Autoscaling is the automatic adjustment of computing resource capacity or running instances in response to workload demand or measured system conditions.
- dataset splitimplemented by · A dataset split is the division of a dataset into distinct subsets assigned different purposes, such as training, validation, or testing.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.