DEV Community: Stephanie Albert

The World of Auto Scaling: What Really Happens Behind the Scenes

Stephanie Albert — Tue, 12 Aug 2025 13:19:13 +0000

It’s 2 PM, traffic is exploding, your servers are struggling, and you’re frantically trying to spin up more instances. Sound familiar? This is exactly why Auto Scaling exists, but most developers only understand the surface level. Auto Scaling gets talked about a lot, but often in vague terms: “It automatically adds servers when traffic spikes.” That’s true, but what’s really happening under the hood? How does AWS know when to add more instances? And how does your application code magically appear on those new instances ready to serve users?

Let’s pull back the curtain and explore the fascinating orchestration that happens every time your application needs to scale.

Auto Scaling in Plain Terms At its core
Auto Scaling is not just in AWS, it’s a way of keeping your application available and responsive, no matter the traffic pattern. It does this by: Monitoring performance metrics (like CPU or requests per second) Deciding when to add or remove compute capacity based on predefined policies Provisioning new resources with the exact application setup you need But there’s a sophisticated orchestration happening between “metric breach” and “new server is live.”

The Scale-Out Lifecycle
Imagine your EC2-hosted application suddenly goes viral. Here’s the full sequence of what happens when AWS Auto Scaling decides to add a new instance.

Step 1 — The Trigger (0–30 seconds)
Auto Scaling works with Amazon CloudWatch to track key metrics you define, such as: CPUUtilization > 70%, RequestCount per target > 1000 requests/min, Memory usage (via custom CloudWatch metrics) or Custom application metrics (queue length, response time). When a threshold is breached, CloudWatch sends a signal to your Auto Scaling Group. The timing here depends on your scaling policy type.

Step 2 — Launching a New Instance (30–90 seconds)
The Auto Scaling Group uses a Launch Template to create a new EC2 instance. That blueprint includes:

AMI (Amazon Machine Image) → Base OS + optional pre-installed app code Instance type (e.g., t3.medium, c5.large)
Security groups & IAM roles for proper access control
User Data script to run commands at boot Storage configuration and network settings
Key Pair to specify the key pair used for SSH access.
Step 3 — Bootstrapping Your Application
Here’s where your application code gets onto the new server. This can happen in two primary ways:

Option A: Pre-baked AMI

Your AMI already contains the full application stack Boot time is quick, just start the app services. This is suitable for applications with infrequent updates.

Option B: Runtime Deployment

The AMI is minimal (base OS only), the User Data script handles everything: Installs dependencies (Node.js, Python, Nginx, etc.), pulls the latest code from S3, CodeDeploy, or Git repository, runs configuration management tools (Ansible, Chef, AWS SSM) and configures environment variables and secrets. This is best for rapid development cycles with frequent deployments.

Step 4 — Joining the Load Balancer Fleet
Once the new instance is running and your application has bootstrapped, it needs to join the traffic distribution system:

Target Group Registration: The Auto Scaling Group automatically registers the new instance with the configured Target Group(s)
Health Check Initiation: The Load Balancer (ALB/NLB) starts performing health checks against the instance using the Target Group’s health check configuration
Health Check Validation: The load balancer sends requests to your defined health check path (e.g., /health or /status) typically every 30 seconds
Healthy Threshold: Requires 2–3 consecutive successful health checks (HTTP 200 responses) before the instance is marked as healthy
Target Group Status: Instance transitions from “initial” → “healthy” status in the Target Group
Traffic Routing: Once marked healthy in the Target Group, the Load Balancer begins routing requests to the new instance
Step 5 — Serving Requests
From the user’s perspective, nothing has changed they just get fast responses. Behind the scenes, the Load Balancer is distributing requests across both original and newly launched instances, all running identical code.

Scale-In — The Reverse Process
When traffic drops and you no longer need the extra capacity. CloudWatch detects metrics below your lower threshold Selection, Auto Scaling chooses an instance to terminate (oldest launch configuration first, then least billed hour). Connection gets drained (Load Balancer stops sending new requests and waits for existing connections to complete) and gracefully shutsdown. Instance receives termination signal, allowing apps to clean up before shutting down, and billing stops.

Scaling Policies: The Brain Behind the Operation
Understanding the different scaling policy types is crucial:

Target Tracking Scaling Best for: Most use cases How it works: Maintains a specific metric target (e.g., 50% CPU) Example: Keep average CPU utilization at 70%
Step Scaling Best for: Predictable traffic patterns How it works: Different scaling actions based on alarm breach size Example: Add 1 instance if CPU > 70%, add 3 instances if CPU > 90%
Predictive Scaling Best for: Regular traffic patterns How it works: Uses machine learning to forecast and pre-scale Example: Scale up every weekday at 8 AM based on historical patterns
Conclusion
This Article transforms Auto Scaling from a mysterious black box to predictable, powerful tool once you understand the orchestration behind it. The next time you see those new instances spinning up during a traffic spike, you’ll know exactly what’s happening under the hood.

Kubernetes with aiops

Stephanie Albert — Sat, 28 Jun 2025 17:07:06 +0000

Hosting a Static Website On S3 bucket With CloudFront.

Stephanie Albert — Fri, 27 Sep 2024 17:07:30 +0000

Overview

In this article, you will learn how to deploy a simple website using HTML, CSS, and JavaScript using Amazon CloudFront and S3.

Amazon Simple Storage Service (S3) allows you to host static websites by providing object level storage. It stores and retrives data as objects iwithin buckets, making it perfect for static website hosting.

Amazon CLoudFront is a Content Delivery Network (CDN) service which utilizes a network of edge locations to cache copies of your website content closer to users, reducing latency and ensuring faster delivery.

Step 1: Log in to AWS and Access S3

Step 2: Create an S3 Bucket

Click on create a bucket
Choose General purpose
Enter a unique name for your bucket
Ensure Block all public access is selected. Leave the rest of the settings at their default values and click Create bucket.

Step 3: Upload Website Files

Once your bucket is successfully created:

Click on the newly created bucket.
Upload your index.html, css , javascript , and any other static files.

Step 4: Set Up CloudFront Distribution

Now, we'll set up a CloudFront Distribution.

Navigate to CloudFront in AWS Console.

Click Create Distribution.
Create a new Origin Access Control (OAC) to securely grant CloudFront access to your S3 bucket.

Set Redirect HTTP TO HTTPS
Since this is a basic tutorial, your website won't need WAF.

Once you’ve completed the setup, AWS will create your CloudFront distribution.

Step 5: Update the s3 Bucket Policy

After creating the CloudFront distribution, you'll see a prompt asking you to update your S3 bucket policy. This step is important to allow CloudFront access the content in your bucket.

Copy the policy, head over to your s3 bucket permissions tab and paste the new policy in the Bucket Policy Editor and save the changes.

Step 6: Access Your Website

Copy the Distribution Domain Name from CloudFront, open it in your browser, and you will see your static website!

Conclusion

You've now successfully hosted a static website using Amazon S3 and Amazon CloudFront. With S3 providing scalable storage and CloudFront ensuring fast, reliable content delivery through its edge locations, your website is well-optimized for performance and availability.

DEPLOYING APACHE WEB SERVER TO AWS EC2

Stephanie Albert — Thu, 05 Sep 2024 13:25:37 +0000

INTRODUCTION

Imagine you are working as a system administrator for a small e-commerce company. The company has a website hosted on shared hosting, but due to increased traffic and performance issues, your team has decided to migrate the website to a more scalable infrastructure using AWS.

Your task is to set up a basic EC2 instance that will serve as the new web server for the company’s website. You’ll create and configure the instance, install a web server (Apache), and deploy a simple static HTML page that announces the migration.

Overview

An Amazon EC2 instance is a cost-effective virtual server in the AWS cloud environment. You have full control over your instance, from the time that you first launch an instance until you terminate the instance. You can choose from a variety of operating systems when you launch your instance. Amazon EC2 provides a wide range of instance types. You can customize your instance to meet your needs by choosing a type that offers the compute resources, memory, storage, and network performance required to run your applications, paying only for what you use.

PREQUISITE :

AWS Account
Key Pair
Security Group
Web Server(Apache)

Step 1:

Click on Launch instance

Step 2:

Launching your instance

Enter the name of your web server and choose the Amazon Machine Image (AMI) of your choice.

If you don't have a key pair, you can simple create one. A key pair is a security credential that authenticates your access to the instance, usually via SSH. A file will be downloaded to your computer once you hit create key pair. Save that file in a secure folder that you could easily access.

customize your security group and launch your instance.

You will receive a confirmation once it is successfully launched.

Step 3:

Connecting to your instance.

They are various ways to connect to your instance, such as Secure Shell (SSH) for macOS or PuTTy on windows, Remote Desktop Protocol(RDP) for Windows instance, EC2 instance connect via the AWS Console, AWS Systems Manager, among others. In this tutorial we will be using EC2 Instance Connect.

Note: You don't need a key pair when using EC2 instance connect.

Step 4:

Installing a Web Server and deploying a simple HTML page.

Once you have successfully connected to your instance, create a file that contains commands for installing the web server, copying and setting permissions for the .html file.

sudo su

nano <filename.sh>

sudo apt update && upgrade -y

sudo apt -y install apache2

sudo systemctl start apache2

sudo systemctl enable apache2

echo "<html><body><h1>Yay, you did it!</h1></body></html>" > <file_path>/index.html

sudo cp <file_path>/index.html /var/www/html/index.html

sudo chown -R www-data:www-data /var/www/html

sudo chmod -R 775 /var/www/html

Make sure the file is executable then run your script and replace with your actual path.

ls -l

chmod +x <filename.sh>

./<filename.sh>

Step 4:

Testing!

Once you have run your script and received no error messages, navigate back to the AWS Console, copy the IP address of the instance, and open it in your browser. It should display the page below:

Congratulations on launching your first EC2 instance!

Conclusion:

By following these steps, you have successfully launched an EC2 instance, connected to it, installed a web server, and deployed a simple web page. This process provides the foundation for hosting websites or applications on AWS, offering scalability and flexibility for your projects.

Understanding The Basic Syntax Of A Dockerfile.

Stephanie Albert — Tue, 12 Mar 2024 21:23:07 +0000

This article will help you understand the basic commands for creating a Dockerfile which you will use when containerizing different applications and also highlight the benefits of a Dockerfile. Whether you are new to Docker or not, this article will provide valuable information and tips when working with a Dockerfile with different programming languages like Python, Go, Node.Js, Rust, PHP, e.t.c. You will also see how to use the docker init command which initializes the creation of Dockerfiles, compose.yaml and other resources that simplifies the process of configuring Docker.

What is a Dockerfile?

A Dockerfile is a script file that contains instructions or commands for building a docker image. The Dockerfile provides instructions to the Docker engine on how to assemble an image. It includes instructions for installing dependencies, copying files, setting environment variables, and configuring the container. It uses a simple, easy-to-read syntax that can be created and edited with any text editor. Once a Dockerfile has been created, it can be used to build an image using the docker build command. The resulting image can then be run as a container using docker run command.

Why is a Dockerfile necessary?

Dockerfiles enable faster, more efficient, consistent deployment processes for applications. It is necessary and beneficial for several reasons when working with Docker and containerized applications such as:
Reproducibility: Dockerfiles provide a clear and reproducible set of instructions for building a Docker image. This helps ensure consistency across different environments, making it easier to share and deploy applications with the confidence that they will behave the same way everywhere.

Version Control: Dockerfiles can be version-controlled along with the source code of an application. This allows teams to track changes to the build process and easily roll back to previous versions if needed. It enhances collaboration and provides a history of how the application's environment has evolved.

Dependency Management: Dockerfiles explicitly list the dependencies and configuration needed for an application to run. This includes base images, system libraries, runtime environments, and any other software dependencies. This makes it easy to understand and manage the software stack of an application.

Efficient Builds: Docker images are built in layers, and Dockerfile instructions contribute to these layers. When a change is made in the codebase or dependencies, only the affected layers need to be rebuilt, making the build process more efficient and faster.

Isolation: Dockerfiles encapsulate the configuration of an application, making it isolated from the underlying host system. This isolation helps avoid conflicts with other applications or dependencies on the host and ensures that the application runs consistently, regardless of the host environment.

Automation: Dockerfiles allow for the automation of the containerization process. Continuous Integration (CI) and Continuous Deployment (CD) pipelines can use Dockerfiles to build and deploy applications automatically. This automation streamlines the development and deployment workflows, reducing the chance of manual errors.

Portability: Dockerfiles contribute to the portability of applications. Since they define the entire environment needed for an application, Docker images created from these Dockerfiles can run consistently on any system that supports Docker. This portability simplifies deployment across different environments, from development to production.

How to create a Dockerfile?

The fundamental Dockerfile command remains consistent but the content and structure varies across different programming languages and technology stack. The basic structure of a Dockerfile is based on a set of simple instructions, such as "FROM", "WORKDIR", "RUN", "COPY", "EXPOSE", "ENV". Each instruction adds a new layer to the image and each layer includes the instructions specified in the previous layer. The final image is a result of all the instructions specified in the Dockerfile.

Note: Create a file called Dockerfile, use any text editor of your choice.

FROM: A dockerfile always starts by importing the base image using this keyword.



From <image>

WORKDIR: this sets the working directory. This means that any instructions that are run in the container will be executed inside the specified directory.



WORKDIR <directory>

COPY: the COPY instruction is used to copy files or directories from the host machine into the container current working directory.



COPY <src> <dst>

If you want to copy all the files from the host current directory to the container's current directory use:



COPY . .

The first "." represents the source directory on the host machine and the second "." represents the destination directory within the container.

RUN: use the run command to execute commands during the image build process. It is used to install necessary packages, run build scripts, e.t.c.



RUN <command>

CMD: this specifies the specific command to run when a container is started.



CMD ["executable","param1","param2",…]

ENV: this instruction sets environment variables inside the container which will be available during build time as well as in a running container(image).



ENV MY_VAR=my_value.

EXPOSE: this command informs docker that the port the container listens to during run time. It is more of a documentation, it doesn't publish the port.



EXPOSE 5000

Apart from the commands listed above, there are many others like ENTRYPOINT, ARG, VOLUME, USER, LABEL, e.t.c which are also used to create a Dockerfile but we focused on the basics.

Sample of a Dockerfile for a Flask App:



FROM python:3.12-slim

EXPOSE 5000

# Keeps Python from generating .pyc files in the container
ENV PYTHONDONTWRITEBYTECODE=1

# Turns off buffering for easier container logging
ENV PYTHONUNBUFFERED=1

# Install pip requirements
COPY requirements.txt .
RUN python -m pip install -r requirements.txt 

WORKDIR /app
COPY . /app

CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

What is Docker Init?

Docker init is a CLI command that helps you initialize Docker resources in your projects. It walks you through the creation of Dockerfiles, compose.yaml, .dockerignore files and so on based on your project's requirements. This helps to save time and reduce complexity when configuring Docker for your projects.

How to use Docker init?

Using Docker init is easy, after installing it, go to the directory of your project where you want to set up Docker.
Create a basic flask app:



from flask import Flask

app = Flask(__name__)

@app.route('/')
def docker():
     return "Dockerfile Tutorial"

if __name__ == '__main__':
    app.run(host='0.0.0.0', debug=True)

Then in your terminal run the docker init command:



docker init

Docker init command will scan your project and ask you to choose the template that best fits your project.

After docker init is completed, you may need to modify the created files and tailor them to your projects.

Note if any of the files exist, a prompt will appear and provide a warning as well as an option to overwrite all the files. You can't recover an overwritten file.

Let's see what the auto-generated Dockerfile looks like:

Conclusion

Creating a Dockerfile can be useful in the automation project or in development as it makes it easy to manage dependencies and system requirements for our application. Instead of having to worry about ensuring that your application has the correct versions of libraries and dependencies installed on the host system, we can easily specify them in the Dockerfile and they will be included in the container image.
This makes it easy to manage and control the dependencies of your application, and it also makes it easy to test your application on different environments. The Docker init command also helps to save time and effort and also write better Dockerfiles, but I would recommend you to cross check the configuration before you push through with it.
Hope you like the article. Thanks for reading!

Source code: https://github.com/Stefanie-A/docker-app-template.git

How To Deploy A Flask App On Digitalocean

Stephanie Albert — Sat, 20 Jan 2024 19:19:41 +0000

Introduction

Flask is a python framework for building web applications. It’s a popular choice for building web apps because of its simplicity and flexibilty. Gunicorn(Green unicorn) is a Python WSGI HTTP server for unix. It acts as a middle layer which receives requests sent to the Web server from a client and forwards them to the Python app. Nginx on other hand is a Web server and reverse proxy which helps in load balancing, caching and handling static files. Docker simplifies your deployment process, allowing you to package your application and its dependencies into a single container.

In this tutorial, we will deploy a flask app to a digitalocean droplet from an existing github repository, utilizing Gunicorn and Nginx and also containerize the app with Docker.

Prerequisites
To follow this tutorial, we will need the following:
Digitalocean account, required for deploying the application.
Git to clone the repository.
Gunicorn installed for running the web applications.
Nginx installed, following steps from Nginx Documentation.
Docker installed for creating and running your container.

Part 1- Creating a Droplet and Installing Gunicorn

We will be deploying our application on digitalocean so you need to create an account.

Step 1: Create a droplet on digitalocean.

The first step is to choose any region of your choice, image for your server, select a CPU option and an authentication method.

Step 2: SSH into your droplet console, install python and clone your github repository of your existing flask application.



sudo apt update
sudo apt install python3 python3-pip python3-venv

This will also install the venv module.

Clone the Github repo

Navigate into your github repository:

Step 3: Create a python virtual environment on your server.(Optional)

Creating a python virtual environment is totally optional. It is used when you have multiple python versions installed on your server.
Make a new directory and navigate into it.



mkdir venv
cd venv

Now create a virtual environment and activate it as shown below.

Your prompt will change to indicate that you are operating inside a virtual environment.
To deactivate simply execute the command below(optional):



deactivate

Step 4: Install Gunicorn

We need to install Gunicorn which will serve our flask app and we also install all requirements necessary for your Flask app from the requirements.txt in the repository.



pip install -r requirements.txt

We will now start your the flask app using the following command.



python app.py

Visit your server’s ip address on your browser.(http://your_server_ip:port).

If we close our terminal, the flask app will stop running. To keep it running in the background, we need Gunicorn as a daemon. It operates as a background process, detaching from the terminal. If you close the terminal or logout without destroying the server the app won’t stop running because daemon continues to run in the background.



gunicorn -b 0.0.0.0:8000 app:app --daemon

Great job! You have successfully deployed your Flask app using Gunicorn.

Part 2-Setting up and Configuring Nginx

Now that you have completed the first part of deploying your Flask app and making it accessible with Gunicorn a web server gateway interface(WSGI) for python applications on your web browser, the next part is to set up Nginx which is a web server for reserve proxy(a server that sits between the client devices and a backend server) handling request from clients and forwarding them to the appropriate backend server and takes the response back to the clients.

Step 1: Install Nginx

Ngnix should be automatically registered as a systemd service and should be running.



sudo apt install nginx -y

To check the status of your nginx if it is running or not use the following command:



sudo systemctl status nginx

If it is not running then execute this command:



sudo systemctl start nginx

Then you are good to go. For visual verification that everything is working properly, visit your server ip address again on your brower(http://your_server_ip), and you should see the Nginx default welcome page.

Step 2: Configuring Nginx

Nginx configuration usually lives in the /etc/nginx directory with the Nginx configuration files ending with .conf extension inside. Navigate into this directory and list all the files:

Let’s move the contents of the nginx.conf file into a new file and create a new configuration file for learning purposes to avoid editing the original nginx.conf file.



#rename file
sudo mv nginx.conf nginx.conf.backup

#create new file
touch nginx.conf

Open your newly created nginx.conf file using any text editor of your choice and write your new configurations. I will be using nano throughout this tutorial. :



sudo nano /etc/ngnix/nginx.conf



events {

}

http {

    server {

        listen 80;
        server_name tutorial.test;

        return 200 "Bonjour, mon ami!\n";
    }

}

Step 3: Validate and reload the configuration file

Validate your configuration file to check for any syntax error. If you have a syntax error this command below will let you know.



sudo nginx -t

The next thing you have to do is to instruct nginx to reload the configuration file:



sudo nginx -s reload

Once you have reloaded the file, simply reload your web browser again.

Congratulations on getting this far!

Part 3- Containerize your App With Docker

One of the benefits about containerising your application(s) is that it allows you to package all dependencies, configuration, system tools and runtime necessary for your application into a single container and deploy it across different environments. In this tutorial we will use docker basic syntax to carry this out.We will only be taking a high level overview of how to use Docker.

Step 1: Install Docker

The first step is to install docker, enable it and start it:



sudo apt install docker.io
sudo systemctl enable docker
sudo systemctl start docker

Step 2: Create a dockerfile

Let's create a dockerfile which is used to build Docker Images. It is a simple text file that consists of a set of instructions or commands that is executed by an automated build process in steps from top to bottom. The dockerfile can be modified to meet your needs.



sudo touch Dockerfile 
sudo nano Dockerfile



FROM python:3.10

WORKDIR /app
COPY requirements.txt /app/

RUN python -m venv venv
Env PATH="/app/venv/bin:$PATH"

RUN pip install --upgrade pip
RUN pip install --no-cache-dir -r requirements.txt

EXPOSE 80  

CMD ["python3.10", "app.py"]

Step 3: Build and Run

Now that your dockerfile is ready, it is time to build an image and run it.



docker build -t tutorial .
docker run -d -p 8080:8000 tutorial

Nice job! Your app has successfully been containerized.

Conclusion

In this tutorial, you learned how to deploy your Flask app and containerize it with docker. We first cloned an existing Flask App from Github into a Digitalocean droplet. Gunicorn was installed which was used to create a python web server gateway interface and also Nginx for reverse proxy which could also be used for caching and load balancing. Docker was used to containerize the app making it possible for you to deploy it in any environment without installing any dependency.

Deployment is essential in making your app operational and accessible by users to interact with it. It is an important step in software deployment life cycle. Through deployment, your app becomes available on servers or cloud platforms, allowing users to access, experience, and benefit from its features, ultimately realizing the software's intended purpose. It is the bridge that connects the development phase to the end-users, ensuring that the app is ready for real-world usage, feedback, and continuous improvement.

I hope you find this article helpful. Thank you🙂.