From 52207c755f6f43d9222b6a4a39a5afeb61945865 Mon Sep 17 00:00:00 2001 From: Kemi-Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Thu, 6 Nov 2025 13:58:17 +0000 Subject: [PATCH 01/16] feat: autoscaling changes made added new intro, use case examples and note about blackfire for users --- .../upsun/src/manage-resources/autoscaling.md | 27 +++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 957d775933..029e35e5fb 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -9,14 +9,37 @@ keywords: - "scaling" --- -Autoscaling allows your applications to automatically [scale horizontally](/manage-resources/adjust-resources.html#horizontal-scaling) based on resource usage. -This ensures your apps remain responsive under load while helping you optimize costs. +# What is autoscaling? + +Autoscaling is a feature that automatically adjusts how many instances of your application are running, increasing capacity when demand rises, and reducing it when things are quiet. It helps your app stay responsive under heavy load while keeping your infrastructure costs efficient. + +Autoscaling works through [horizontal scaling](/manage-resources/adjust-resources.html#horizontal-scaling), by adding or removing whole application instances depending on resource usage. If CPU utilization stays above a certain threshold for a set time, {{% vendor/name %}} automatically adds more instances. If it stays low, {{% vendor/name %}} removes unneeded ones. You control these thresholds, cooldowns, and limits, so scaling always happens safely and predictably. - **Scope:** Available for applications only - **Product tiers:** Available for all Upsun Flex environments - **Environments:** Configurable per environment - across development, staging, and production +{{< note theme="info" title="Know your app first">}} +Autoscaling is quick to set up: you can [enable it in a few clicks](#enable-autoscaling) from your environment’s **Configure resources** tab. However, because it reacts to real traffic patterns, it’s important to understand your app’s typical performance before turning it on. + +Tools like [Blackfire](https://www.blackfire.io/) can help you identify where your app consumes CPU or memory, so you can set realistic thresholds that reflect your traffic patterns. Blackfire can also help you spot whether autoscaling is likely to benefit your app or if a fixed setup with tuned [vertical resources](/manage-resources/adjust-resources.html#vertical-scaling) like CPU/RAM would serve you better. +{{< /note >}} + +## When to use autoscaling + +Autoscaling makes the most sense for workloads with variable or unpredictable traffic. It’s especially valuable when: + +- You run time-sensitive or customer-facing applications where latency matters. +- Your app experiences seasonal or campaign-driven spikes. +- You want to avoid paying for idle capacity during quieter periods. + +### Example: When autoscaling works effectively +A retail app sees traffic jump fivefold every Friday evening and during holiday campaigns. By enabling autoscaling, the app automatically adds instances when CPU usage rises and scales back overnight, ensuring smooth checkouts without wasted cost. + +### Example: When autoscaling might not be needed +An internal dashboard with predictable, low usage may not benefit from autoscaling. In this case, a fixed number of instances and tuned vertical resources (CPU/RAM) can be more cost-effective and stable. + {{< note theme="info" title="Scale databases and resources">}} To vertically scale CPU, RAM, or disk, or horizontally scale applications and workers (manually), see: From e05c138f3592247e592384bf100510e6296666fe Mon Sep 17 00:00:00 2001 From: Kemi-Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Thu, 6 Nov 2025 14:07:34 +0000 Subject: [PATCH 02/16] feat: added memory based autoscaling section added memory based autoscaling section --- .../upsun/src/manage-resources/autoscaling.md | 44 ++++++++++++++++++- 1 file changed, 43 insertions(+), 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 029e35e5fb..def6fc4cdf 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -84,7 +84,6 @@ The tables below outline where autoscaling and manual scaling are supported, so | Average CPU (min/max) | Available | | Average Memory (min/max) | Coming | - ## How autoscaling works ### Thresholds @@ -126,6 +125,49 @@ When autoscaling is enabled, [manual instance count](/manage-resources/adjust-re This cycle ensures your app automatically scales up during high demand and scales down when demand drops, helping balance performance with cost efficiency. +## Memory-based autoscaling + +Autoscaling primarily relies on CPU utilization as its trigger, however you can also configure memory-based autoscaling, which works in a similar way, but with a few important differences to understand. + +### CPU-based triggers + +CPU-based autoscaling reacts to sustained changes in average CPU utilization. + +- Scale-up threshold: When average CPU usage stays above your defined limit for the evaluation period, Upsun adds instances to distribute the load. +- Scale-down threshold: When CPU usage remains below your lower limit for the evaluation period, instances are removed to save resources. +- Cooldown window: A delay (default: 5 minutes) before another scaling action can occur. + +This approach works well for CPU-intensive workloads such as request-heavy APIs or web apps that process data or run frequent computations. + +### Memory-based triggers + +Memory-based autoscaling follows the same principle as CPU triggers but measures average memory utilization instead. When your app consistently uses more memory than your upper threshold, {{% vendor/name %}} adds instances; when memory usage remains low, it removes them. + +This option is useful for workloads where memory pressure, caching, or in-memory data handling determine performance — for example, large data processing apps or services with persistent caching layers. + +#### Example + +| Condition | Scaling action | +|------------|----------------| +| Memory above 80% for 5 minutes | Scale up: Add one instance | +| Memory below 30% for 5 minutes | Scale down: Remove one instance | + +{{< note theme="warning" title="Understand your app’s memory profile" >}} +High memory usage doesn’t always mean your app needs more instances. Linux systems use available memory for caching and buffering, so 90–100% usage can be normal even under stable conditions. Before using memory-based autoscaling, profile your application’s typical memory behavior to avoid unnecessary scaling and extra cost. + +Tools such as [Blackfire](https://www.blackfire.io/) or system-level metrics in your [Application metrics dashboard](/increase-observability/application-metrics.html) can help you understand what “normal” looks like for your app. +{{< /note >}} + +#### Step-by-step: Configure memory triggers +1. Open your project in the Console. +2. Select your target environment. +3. Choose **Configure resources**. +4. Under **Autoscaling**, select **Enable** (if not already enabled). +5. Choose **Memory usage (min/max)** as your scaling trigger. +6. Set scale-up and scale-down thresholds, evaluation period, and cooldown window. +7. Save changes — your app will now automatically scale based on memory utilization. + + ## Guardrails and evaluation Autoscaling gives you control over the minimum and maximum number of instances your app can run. These guardrails ensure your app never scales up or down too far. Set boundaries to keep scaling safe, predictable, and cost-efficient: From 4e28556fec09950f21d203e575bc7df980eb0a6a Mon Sep 17 00:00:00 2001 From: Kemi Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 11:34:02 +0000 Subject: [PATCH 03/16] Apply suggestion from @Kemi-Elizabeth --- sites/upsun/src/manage-resources/autoscaling.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 44f66dd533..769381a40a 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -136,7 +136,7 @@ Autoscaling primarily relies on CPU utilization as its trigger, however you can CPU-based autoscaling reacts to sustained changes in average CPU utilization. -- Scale-up threshold: When average CPU usage stays above your defined limit for the evaluation period, Upsun adds instances to distribute the load. +- Scale-up threshold: When average CPU usage stays above your defined limit for the evaluation period, instances are added to distribute the load. - Scale-down threshold: When CPU usage remains below your lower limit for the evaluation period, instances are removed to save resources. - Cooldown window: A delay (default: 5 minutes) before another scaling action can occur. From c3f16b26669c1812e1ba415f941b92c886f8c1a1 Mon Sep 17 00:00:00 2001 From: Kemi Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 11:34:32 +0000 Subject: [PATCH 04/16] Apply suggestion from @Kemi-Elizabeth --- sites/upsun/src/manage-resources/autoscaling.md | 1 - 1 file changed, 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 769381a40a..3d8e75839e 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -140,7 +140,6 @@ CPU-based autoscaling reacts to sustained changes in average CPU utilization. - Scale-down threshold: When CPU usage remains below your lower limit for the evaluation period, instances are removed to save resources. - Cooldown window: A delay (default: 5 minutes) before another scaling action can occur. -This approach works well for CPU-intensive workloads such as request-heavy APIs or web apps that process data or run frequent computations. ### Memory-based triggers From 26c6d3e0e42cf0686201901ee4523a28af3532a4 Mon Sep 17 00:00:00 2001 From: Kemi Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 11:34:45 +0000 Subject: [PATCH 05/16] Apply suggestion from @Kemi-Elizabeth --- sites/upsun/src/manage-resources/autoscaling.md | 1 - 1 file changed, 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 3d8e75839e..3bb847d226 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -140,7 +140,6 @@ CPU-based autoscaling reacts to sustained changes in average CPU utilization. - Scale-down threshold: When CPU usage remains below your lower limit for the evaluation period, instances are removed to save resources. - Cooldown window: A delay (default: 5 minutes) before another scaling action can occur. - ### Memory-based triggers Memory-based autoscaling follows the same principle as CPU triggers but measures average memory utilization instead. When your app consistently uses more memory than your upper threshold, {{% vendor/name %}} adds instances; when memory usage remains low, it removes them. From 0802913752880c9ee654d6fab6b4546247d28071 Mon Sep 17 00:00:00 2001 From: Kemi Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 11:36:14 +0000 Subject: [PATCH 06/16] Apply suggestion from @Kemi-Elizabeth --- sites/upsun/src/manage-resources/autoscaling.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 3bb847d226..8de0096ecd 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -144,7 +144,7 @@ CPU-based autoscaling reacts to sustained changes in average CPU utilization. Memory-based autoscaling follows the same principle as CPU triggers but measures average memory utilization instead. When your app consistently uses more memory than your upper threshold, {{% vendor/name %}} adds instances; when memory usage remains low, it removes them. -This option is useful for workloads where memory pressure, caching, or in-memory data handling determine performance — for example, large data processing apps or services with persistent caching layers. +This option is useful for workloads where caching or in-memory data handling determine performance - for example, large data processing apps or services with persistent caching layers. #### Example From 4bba148fee2e83ec7d35268b292906ce6fa8628c Mon Sep 17 00:00:00 2001 From: Kemi Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 11:37:09 +0000 Subject: [PATCH 07/16] Apply suggestion from @Kemi-Elizabeth --- sites/upsun/src/manage-resources/autoscaling.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 8de0096ecd..0a06006b5a 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -159,7 +159,7 @@ High memory usage doesn’t always mean your app needs more instances. Linux sys Tools such as [Blackfire](https://www.blackfire.io/) or system-level metrics in your [Application metrics dashboard](/increase-observability/application-metrics.html) can help you understand what “normal” looks like for your app. {{< /note >}} -#### Step-by-step: Configure memory triggers +#### Configure memory triggers 1. Open your project in the Console. 2. Select your target environment. 3. Choose **Configure resources**. From 786ca98d7c7ccbcd7052c7264b464416b938ac0d Mon Sep 17 00:00:00 2001 From: Kemi Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 11:50:59 +0000 Subject: [PATCH 08/16] Apply suggestion from @Kemi-Elizabeth --- sites/upsun/src/manage-resources/autoscaling.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 0a06006b5a..16490dad19 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -10,7 +10,7 @@ keywords: --- -# What is autoscaling? +## What is autoscaling? Autoscaling is a feature that automatically adjusts how many instances of your application are running, increasing capacity when demand rises, and reducing it when things are quiet. It helps your app stay responsive under heavy load while keeping your infrastructure costs efficient. From d62cec0b8fc15be293c4da5b6b98cbd08d4eee9e Mon Sep 17 00:00:00 2001 From: Kemi-Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 13:16:16 +0000 Subject: [PATCH 09/16] feat: adjusted table made memory available in table --- sites/upsun/src/manage-resources/autoscaling.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 16490dad19..7e6f0fdf77 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -82,7 +82,7 @@ The tables below outline where autoscaling and manual scaling are supported, so | Trigger | Console | | ------------------------- | ----------- | | Average CPU (min/max) | Available | -| Average Memory (min/max) | Coming | +| Average Memory (min/max) | Available | ## How autoscaling works From 1131ea372f22be79c2e512428d23c5010b8878f3 Mon Sep 17 00:00:00 2001 From: Kemi Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 13:17:44 +0000 Subject: [PATCH 10/16] Apply suggestion from @Kemi-Elizabeth --- sites/upsun/src/manage-resources/autoscaling.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 7e6f0fdf77..cae7bd0601 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -14,7 +14,7 @@ keywords: Autoscaling is a feature that automatically adjusts how many instances of your application are running, increasing capacity when demand rises, and reducing it when things are quiet. It helps your app stay responsive under heavy load while keeping your infrastructure costs efficient. -Autoscaling works through [horizontal scaling](/manage-resources/adjust-resources.html#horizontal-scaling), by adding or removing whole application instances depending on resource usage. If CPU utilization stays above a certain threshold for a set time, {{% vendor/name %}} automatically adds more instances. If it stays low, {{% vendor/name %}} removes unneeded ones. You control these thresholds, cooldowns, and limits, so scaling always happens safely and predictably. +Autoscaling works through [horizontal scaling](/manage-resources/adjust-resources.html#horizontal-scaling), by adding or removing whole application instances depending on resource usage. If CPU utilization stays above a certain threshold for a set time, {{% vendor/name %}} automatically adds more instances. If it stays low, {{% vendor/name %}} removes unneeded ones. You control these thresholds and limits, so scaling always happens safely and predictably. - **Scope:** Available for applications only - **Product tiers:** Available for all Upsun Flex environments From cd62764efa27cadc561503cd96b2a77d0537bb1c Mon Sep 17 00:00:00 2001 From: Kemi-Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 13:19:11 +0000 Subject: [PATCH 11/16] feat: moved title moved subheading --- sites/upsun/src/manage-resources/autoscaling.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 7e6f0fdf77..0c4b168453 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -9,11 +9,10 @@ keywords: - "scaling" --- +Autoscaling is a feature that automatically adjusts how many instances of your application are running, increasing capacity when demand rises, and reducing it when things are quiet. It helps your app stay responsive under heavy load while keeping your infrastructure costs efficient. ## What is autoscaling? -Autoscaling is a feature that automatically adjusts how many instances of your application are running, increasing capacity when demand rises, and reducing it when things are quiet. It helps your app stay responsive under heavy load while keeping your infrastructure costs efficient. - Autoscaling works through [horizontal scaling](/manage-resources/adjust-resources.html#horizontal-scaling), by adding or removing whole application instances depending on resource usage. If CPU utilization stays above a certain threshold for a set time, {{% vendor/name %}} automatically adds more instances. If it stays low, {{% vendor/name %}} removes unneeded ones. You control these thresholds, cooldowns, and limits, so scaling always happens safely and predictably. - **Scope:** Available for applications only From 9fd1f596edd24fb489de91ebbcebeaff51b1c726 Mon Sep 17 00:00:00 2001 From: Kemi Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 13:34:10 +0000 Subject: [PATCH 12/16] Apply suggestion from @Kemi-Elizabeth --- sites/upsun/src/manage-resources/autoscaling.md | 1 - 1 file changed, 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 367250a1d0..39d12830d4 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -13,7 +13,6 @@ Autoscaling is a feature that automatically adjusts how many instances of your a ## What is autoscaling? -Autoscaling is a feature that automatically adjusts how many instances of your application are running, increasing capacity when demand rises, and reducing it when things are quiet. It helps your app stay responsive under heavy load while keeping your infrastructure costs efficient. Autoscaling works through [horizontal scaling](/manage-resources/adjust-resources.html#horizontal-scaling), by adding or removing whole application instances depending on resource usage. If CPU utilization stays above a certain threshold for a set time, {{% vendor/name %}} automatically adds more instances. If it stays low, {{% vendor/name %}} removes unneeded ones. You control these thresholds and limits, so scaling always happens safely and predictably. From 662857ee493c27c79149cb8ed00e35fbd6a9ea1e Mon Sep 17 00:00:00 2001 From: Kemi Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 13:34:22 +0000 Subject: [PATCH 13/16] Apply suggestion from @Kemi-Elizabeth --- sites/upsun/src/manage-resources/autoscaling.md | 1 - 1 file changed, 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 39d12830d4..9250397c8f 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -13,7 +13,6 @@ Autoscaling is a feature that automatically adjusts how many instances of your a ## What is autoscaling? - Autoscaling works through [horizontal scaling](/manage-resources/adjust-resources.html#horizontal-scaling), by adding or removing whole application instances depending on resource usage. If CPU utilization stays above a certain threshold for a set time, {{% vendor/name %}} automatically adds more instances. If it stays low, {{% vendor/name %}} removes unneeded ones. You control these thresholds and limits, so scaling always happens safely and predictably. - **Scope:** Available for applications only From 2386e58a78a091cd8e734aff183d667f1f2ef90b Mon Sep 17 00:00:00 2001 From: Kemi-Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Fri, 7 Nov 2025 15:29:48 +0000 Subject: [PATCH 14/16] feat: started making changes changes suggested by Ricardo - adjusted meta description, adjusted thresholds section --- sites/upsun/src/manage-resources/autoscaling.md | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 9250397c8f..ee35190e3e 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -1,6 +1,6 @@ --- title: Autoscaling -description: Learn how autoscaling dynamically adjusts app instances based on CPU usage to keep apps responsive under load while optimizing costs. +description: Learn how autoscaling adjusts app instances based on CPU and memory usage to keep apps stable and cost-efficient under varying workloads. weight: -100 keywords: - "resources" @@ -87,7 +87,11 @@ The tables below outline where autoscaling and manual scaling are supported, so ### Thresholds -Autoscaling continuously monitors the average CPU utilization across your app's running instances. It works by you setting your thresholds, which are specific CPU usage levels that determine when autoscaling should take action. There are two different thresholds that your CPU utilization operates within: A scale-up threshold and a scale-down threshold. + +Autoscaling monitors the average CPU and [memory usage](#memory-based-autoscaling) of your running app instances. +You define thresholds that determine when new instances are launched or removed. + +There are two different thresholds that your CPU and memory utilization operate within: A scale-up threshold and a scale-down threshold. - **Scale-up threshold**: If your chosen trigger (e.g. CPU usage) stays **above** this level for the time period you've set (the evaluation period), autoscaling will launch additional instances to share the load. @@ -95,6 +99,13 @@ Autoscaling continuously monitors the average CPU utilization across your app's To prevent unnecessary back-and-forth, autoscaling also uses a cooldown window: a short waiting period before another scaling action can be triggered. This can also be configured or kept to the [default](#default-settings) waiting period before any additional scaling starts. +{{< note theme="warning" title="Combined triggers" >}} + +If both CPU and memory triggers are enabled, either one can initiate scaling. A global cooldown applies after each scaling event, but in rare cases, combined triggers may interact unexpectedly. For example, CPU scaling up followed by memory scaling down. Adjust thresholds and cooldowns carefully to avoid oscillation. + +{{< /note >}} + + ### Default settings Autoscaling continuously monitors the configured **trigger** across your app’s running instances. We will use the **average CPU utilization** trigger as the primary example for the default settings and examples below. From 36561cc65208cf07a5fc5d9450de4657a6d93ac9 Mon Sep 17 00:00:00 2001 From: Kemi-Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Thu, 13 Nov 2025 16:24:11 +0000 Subject: [PATCH 15/16] feat: made suggested changes made more changes suggested by Ricardo --- sites/upsun/src/manage-resources/autoscaling.md | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index ee35190e3e..21c37377fd 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -13,14 +13,14 @@ Autoscaling is a feature that automatically adjusts how many instances of your a ## What is autoscaling? -Autoscaling works through [horizontal scaling](/manage-resources/adjust-resources.html#horizontal-scaling), by adding or removing whole application instances depending on resource usage. If CPU utilization stays above a certain threshold for a set time, {{% vendor/name %}} automatically adds more instances. If it stays low, {{% vendor/name %}} removes unneeded ones. You control these thresholds and limits, so scaling always happens safely and predictably. +Autoscaling works through [horizontal scaling](/manage-resources/adjust-resources.html#horizontal-scaling), by adding or removing whole application instances depending on resource usage. If CPU or [memory](#memory-based-autoscaling) utilization stays above a certain threshold for a set time, {{% vendor/name %}} automatically adds more instances. If it stays low, {{% vendor/name %}} removes unneeded ones. You control these thresholds and limits, so scaling always happens safely and predictably. - **Scope:** Available for applications only - **Product tiers:** Available for all Upsun Flex environments - **Environments:** Configurable per environment - across development, staging, and production {{< note theme="info" title="Know your app first">}} -Autoscaling is quick to set up: you can [enable it in a few clicks](#enable-autoscaling) from your environment’s **Configure resources** tab. However, because it reacts to real traffic patterns, it’s important to understand your app’s typical performance before turning it on. +Autoscaling is quick to set up: you can [enable it in a few clicks](#enable-autoscaling) from your environment’s **Configure resources** tab. However, it’s important to understand your app’s typical performance before turning it on. Tools like [Blackfire](https://www.blackfire.io/) can help you identify where your app consumes CPU or memory, so you can set realistic thresholds that reflect your traffic patterns. Blackfire can also help you spot whether autoscaling is likely to benefit your app or if a fixed setup with tuned [vertical resources](/manage-resources/adjust-resources.html#vertical-scaling) like CPU/RAM would serve you better. {{< /note >}} @@ -87,7 +87,6 @@ The tables below outline where autoscaling and manual scaling are supported, so ### Thresholds - Autoscaling monitors the average CPU and [memory usage](#memory-based-autoscaling) of your running app instances. You define thresholds that determine when new instances are launched or removed. @@ -178,7 +177,6 @@ Tools such as [Blackfire](https://www.blackfire.io/) or system-level metrics in 6. Set scale-up and scale-down thresholds, evaluation period, and cooldown window. 7. Save changes — your app will now automatically scale based on memory utilization. - ## Guardrails and evaluation Autoscaling gives you control over the minimum and maximum number of instances your app can run. These guardrails ensure your app never scales up or down too far. Set boundaries to keep scaling safe, predictable, and cost-efficient: From 5e8085e4d11601ae0338039ad5fb72c9e392d4e0 Mon Sep 17 00:00:00 2001 From: Kemi-Elizabeth <97071326+Kemi-Elizabeth@users.noreply.github.com> Date: Thu, 13 Nov 2025 16:31:51 +0000 Subject: [PATCH 16/16] feat: vale adjustments vale doesn't like use of cooldown so adjusted settings --- sites/upsun/src/manage-resources/autoscaling.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sites/upsun/src/manage-resources/autoscaling.md b/sites/upsun/src/manage-resources/autoscaling.md index 6e77494050..fc01a56c1b 100644 --- a/sites/upsun/src/manage-resources/autoscaling.md +++ b/sites/upsun/src/manage-resources/autoscaling.md @@ -8,7 +8,7 @@ keywords: - "autoscaling" - "scaling" --- - + Autoscaling is a feature that automatically adjusts how many instances of your application are running, increasing capacity when demand rises, and reducing it when things are quiet. It helps your app stay responsive under heavy load while keeping your infrastructure costs efficient. ## What is autoscaling? @@ -305,3 +305,4 @@ Scaling down to zero instances is also **not supported**. Use minimum instance c - [Payment FAQ](/administration/billing/payment-faq.html) - [Monitor billing](/administration/billing/monitor-billing.html) - [Pricing overview](https://www.upsun.com/pricing/) + \ No newline at end of file