How to Deploy a Python Flask App to AWS Elastic Beanstalk
Deploying a Python Flask application to AWS Elastic Beanstalk simplifies scaling and management for web apps. This guide walks through building a basic Flask app and deploying it to Elastic Beanstalk, handling server configuration automatically so you focus on code. Prerequisites include Python 3.12 installed, an AWS account, the AWS CLI, and the Elastic Beanstalk CLI (eb-cli); familiarity with virtual environments helps too.
Setup
Create a new directory for your project and navigate into it. Use a virtual environment to isolate dependencies. This keeps your project clean and avoids conflicts with system packages.
mkdir flask-eb-app
cd flask-eb-app
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
Install Flask and other required packages next. Flask handles the web framework, while gunicorn serves as the WSGI server for production. These tools ensure your app runs efficiently in a deployed environment.
pip install flask gunicorn
pip freeze > requirements.txt
Initialize your project structure with essential files. The application.py file will hold your Flask code, and requirements.txt lists dependencies for Elastic Beanstalk to install. This setup prepares your app for deployment without manual package management on the server.
Creating the Flask Application
Start by writing a simple Flask app that responds to requests. This code defines routes and runs the server, demonstrating basic functionality. Explaining the structure helps you understand how Flask processes incoming requests.
# application.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
return "Hello, Elastic Beanstalk!"
@app.route('/health')
def health():
return "OK", 200
if __name__ == '__main__':
app.run(debug=True)
Run the app locally to verify it works. Access it in your browser at http://127.0.0.1:5000/. You should see "Hello, Elastic Beanstalk!" on the home page, confirming the routes are set up correctly.
python application.py
Expected output in the terminal includes server startup messages like "* Running on http://127.0.0.1:5000". Visiting the /health route returns "OK" with a 200 status, useful for later health checks in deployment.
⚠️ Note: Avoid using the development server in production; it's not secure or efficient for real traffic. Switch to gunicorn for deployment to handle multiple requests reliably.
Configuring for Elastic Beanstalk
Elastic Beanstalk requires a configuration file to recognize your app. Create .ebextensions with a python.config file to specify runtime settings. This tells Beanstalk to use Python 3.12 and run your app with gunicorn.
mkdir .ebextensions
# .ebextensions/python.config
option_settings:
aws:elasticbeanstalk:container:python:
WSGIPath: application.py
Add a Procfile to define the web process. This file instructs Beanstalk to start gunicorn with your app module. It ensures the app launches correctly on the server with the right number of workers.
# Procfile
web: gunicorn -w 4 -k gevent -b 0.0.0.0:$PORT application:app
Why gevent? It handles asynchronous operations better than default workers, improving performance for I/O-bound apps. Test this locally by running gunicorn instead of Flask's server.
gunicorn -w 4 -k gevent -b 0.0.0.0:8000 application:app
Expected output shows gunicorn starting workers, and accessing http://127.0.0.1:8000/ displays the same "Hello, Elastic Beanstalk!" message. This confirms compatibility before deployment.
⚠️ Note: If you encounter "ModuleNotFoundError", ensure requirements.txt includes all packages and your virtual environment is active. Double-check imports in application.py to match installed modules.
Deploying to AWS Elastic Beanstalk
Initialize the Elastic Beanstalk environment from your project directory. Use the eb command to set up a new application. This creates the necessary AWS resources without manual console navigation.
eb init -p python-3.12 flask-eb-app --region us-west-2
The init command prompts for AWS credentials if not configured. It generates an application name and sets the platform to Python 3.12. Check .elasticbeanstalk/config.yml for your settings.
Create and deploy the environment next. This command provisions servers, installs dependencies from requirements.txt, and deploys your code. Beanstalk handles load balancing and scaling automatically.
eb create flask-env
eb deploy
Deployment takes a few minutes; monitor progress with eb status. Once complete, eb open launches the app in your browser. You should see "Hello, Elastic Beanstalk!" at the provided URL, like http://flask-env.eba-xxxxxxxx.us-west-2.elasticbeanstalk.com/.
⚠️ Note: If deployment fails with permission errors, verify your AWS IAM user has ElasticBeanstalkFullAccess policy. Also, ensure no typos in .ebextensions files, as they can halt the process.
Testing and Verification
After deployment, test the app's endpoints. Use curl or a browser to hit the root and health routes. This verifies that the app is live and responding as expected on AWS infrastructure.
curl http://flask-env.eba-xxxxxxxx.us-west-2.elasticbeanstalk.com/
Expected output: "Hello, Elastic Beanstalk!". For the health check, curl http://your-app-url/health should return "OK". Monitor logs with eb logs to debug any issues, ensuring no errors appear during requests.
Scale the environment by updating instance types or adding auto-scaling via the AWS console. Test under load by sending multiple requests simultaneously. If everything responds correctly, your deployment is successful.
⚠️ Note: Beanstalk environments incur costs; terminate unused ones with eb terminate to avoid charges. Always check the AWS Free Tier limits if you're testing on a new account.
This tutorial built and deployed a simple Flask app to AWS Elastic Beanstalk, automating server management for scalable web services. Extend it by adding database integration with RDS or implementing CI/CD with CodePipeline for automated updates. Experiment with environment variables for configuration to make your app more flexible in production.
