DeepSeek V3.2

What We're Building

We'll deploy a production-ready Python Flask application to AWS Elastic Beanstalk. This service automatically handles deployment, capacity provisioning, load balancing, and application health monitoring. You'll have a live web application accessible via a public URL. Prerequisites: an AWS account, Python 3.12+, and basic familiarity with Flask and the command line.

Environment and Project Setup

First, create a clean project directory and set up a virtual environment. This isolates your application's dependencies.

mkdir flask-eb-deploy
cd flask-eb-deploy
python3.12 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

Your terminal prompt should now show (venv). Install the required packages: Flask for the web framework and Gunicorn as the production WSGI server.

pip install flask gunicorn
pip freeze > requirements.txt

The requirements.txt file is critical. Elastic Beanstalk uses it to install your dependencies. Your initial project structure should look like this:

flask-eb-deploy/
├── venv/
└── requirements.txt

Creating the Flask Application

Create the main application file. This will be a simple API with a root endpoint and a health check, which Elastic Beanstalk can monitor.

# app.py
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify({
        'message': 'Flask App on AWS Elastic Beanstalk',
        'status': 'success'
    })

@app.route('/health')
def health():
    return jsonify({'status': 'healthy'}), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

Test the application locally to ensure it works. Run the development server.

python app.py

Open your browser to http://localhost:8080. You should see the JSON message. Visit http://localhost:8080/health to see the health status. Press Ctrl+C to stop the server.

⚠️ Note: We set the host to 0.0.0.0. This makes the server publicly available, which is required for the Elastic Beanstalk environment. The default 127.0.0.1 would not work.

Configuring for Elastic Beanstalk

Elastic Beanstalk needs two configuration files. First, create a .platform directory for platform-specific hooks, then add a configuration file for the WSGI server.

mkdir -p .platform/nginx/conf.d

# .platform/nginx/conf.d/proxy.conf
# Increase the default timeout for the proxy
proxy_connect_timeout 300;
proxy_send_timeout 300;
proxy_read_timeout 300;
send_timeout 300;

This Nginx configuration increases timeouts, which is often necessary for applications with longer requests. Next, create the critical WSGI configuration file.

# wsgi.py
from app import app

if __name__ == "__main__":
    app.run()

This file serves as the entry point for Gunicorn. Elastic Beanstalk looks for an object named application by default. Since our Flask instance is named app, we import it directly. The platform will handle running it with Gunicorn.

⚠️ Note: The file must be named wsgi.py. Elastic Beanstalk's Python platform has specific expectations. Using a different name will cause a deployment failure.

Update your requirements.txt to ensure the exact versions are locked. This prevents unexpected breaks from dependency updates.

pip freeze > requirements.txt

Your final project structure should now be:

flask-eb-deploy/
├── .platform/
│   └── nginx/
│       └── conf.d/
│           └── proxy.conf
├── venv/
├── app.py
├── requirements.txt
└── wsgi.py

Deploying with the EB CLI

The easiest deployment method uses the Elastic Beanstalk Command Line Interface. Install and initialize it.

pip install awsebcli
eb --version

Initialize your Elastic Beanstalk application. This command creates the configuration files locally and sets up the application on AWS.

eb init -p python-3.12 flask-tutorial-app --region us-east-1

You will be prompted for AWS credentials. Follow the instructions to log in. This command sets up a Python 3.12 application named flask-tutorial-app in the US East (N. Virginia) region. Now, create the actual environment where your code will run.

eb create flask-tutorial-env

This step takes 5-10 minutes. It provisions all AWS resources: EC2 instances, a load balancer, security groups, and Auto Scaling groups. Wait for the command to complete successfully.

⚠️ Note: The eb create command defaults to a load-balanced, auto-scaling environment. For a low-cost, single-instance test environment, use eb create --single flask-tutorial-env.

Testing and Verification

Once deployment finishes, open your application in a browser to verify it's live.

eb open

Your default browser will open to your application's public URL (e.g., flask-tutorial-env.eba-abc123.us-east-1.elasticbeanstalk.com). You should see the JSON message from the root route. Check the health endpoint by appending /health to the URL. It should return {"status": "healthy"}.

You can view logs directly from the CLI if you encounter issues. This is the first place to check for deployment or runtime errors.

eb logs

To make a code change, update your local files, then redeploy using the eb deploy command. Let's add a new endpoint.

# Add to app.py, before the if __name__ block
@app.route('/api/data')
def get_data():
    sample_data = {"items": [{"id": 1, "name": "Sample Item"}]}
    return jsonify(sample_data)

eb deploy

The deploy command packages your application and updates the running environment. After it completes, run eb open again and navigate to the /api/data path to see the new endpoint.

Managing Your Deployment

You now have a live, managed Flask application. To view your environment's status or configuration in the AWS Management Console, use this command:

eb console

This opens the Elastic Beanstalk dashboard for your environment. Here you can monitor health, view alarms, adjust capacity, and manage configuration. When you are finished and want to avoid ongoing charges, terminate your environment.

⚠️ Warning: This will delete all AWS resources for this environment, including the EC2 instance and load balancer. Your application will no longer be accessible.

eb terminate flask-tutorial-env

Type the environment name to confirm. The application itself (flask-tutorial-app) remains in your EB dashboard, allowing you to create new environments from it later.

You've successfully deployed a Flask application to a production-grade AWS service. The setup handles scaling, load balancing, and health monitoring. Next steps could be connecting a database like Amazon RDS, setting up a custom domain with Route 53, or implementing a CI/CD pipeline using the eb deploy command.