Deploying Python Apps to AWS: A Complete Beginner's Guide

Deploying Python Apps to AWS: A Complete Beginner's Guide

Deploying a Python app to AWS means packaging your code so one of AWS's compute services — EC2, Lambda, or Elastic Beanstalk — can run it and expose it to the internet. Think of it like moving from cooking in your own kitchen (your laptop) to running a food stall in a shared market (the cloud): the recipe doesn't change, but now other people can walk up and order.

This guide covers the four real deployment paths with working commands, and says plainly when a simpler platform beats AWS.

Before AWS: Should You Use AWS?

AWS is powerful, but it's not always the right choice for beginners. Let me be direct:

Consider Railway, Render, or Fly.io first if:

• You're deploying a hobby project or portfolio piece
• You want to deploy in under 10 minutes without learning AWS
• You don't specifically need AWS for a job or project requirement

Use AWS if:

• Your team or employer uses AWS
• You need specific AWS services (RDS, S3, SQS)
• You're learning AWS for career reasons
• Your app needs to scale significantly

For a portfolio project, Railway or Render gives you a live URL in 5 minutes. AWS gives you the same result in 30–60 minutes with more configuration. Know your goal before choosing.

Option 1: AWS Lambda (Serverless Python)

AWS Lambda runs Python functions in response to events — HTTP requests, scheduled triggers, file uploads — without you managing any server. It behaves like a vending machine: it sits idle costing nothing, then springs to life the instant someone presses a button, and switches off again right after.

Deploying a Simple FastAPI App to Lambda

# main.py
from fastapi import FastAPI
from mangum import Mangum

app = FastAPI()

@app.get("/")
def root():
    return {"message": "Running on Lambda"}

@app.get("/hello/{name}")
def hello(name: str):
    return {"message": f"Hello, {name}!"}

# Mangum wraps FastAPI for Lambda
handler = Mangum(app)

Deployment with AWS SAM

# Install AWS CLI and SAM CLI
pip install aws-sam-cli

Create template.yaml:

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  PythonApi:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: .
      Handler: main.handler
      Runtime: python3.11
      MemorySize: 256
      Timeout: 30
      Events:
        Api:
          Type: HttpApi
          Properties:
            Path: /{proxy+}
            Method: ANY

Create requirements.txt:

fastapi
mangum

Deploy:

sam build
sam deploy --guided

SAM will ask for a stack name, region, and confirmation. After deployment, you'll receive an API URL.

Limitations of Lambda:

• Cold starts (first request after ~5 minutes idle is slower — 500ms–2s)
• 15 minute maximum execution time
• Local file system is read-only (use S3 for file storage)
• 10GB maximum package size

Option 2: EC2 (Virtual Machine)

Amazon EC2 gives you a full virtual machine that runs around the clock — the opposite of Lambda's vending-machine model. It's closer to renting an apartment: you get full control of the space, but you're also responsible for setup, maintenance, and the rent whether you use it or not.

Step 1: Launch an EC2 Instance

1. Sign into AWS Console → EC2 → Launch Instance
2. Choose: Ubuntu Server 22.04 LTS (free tier eligible)
3. Instance type: t2.micro (free tier)
4. Key pair: Create new, download .pem file
5. Security group: Allow SSH (port 22) and HTTP (port 80)
6. Launch

Step 2: Connect to Your Instance

# Make key file secure
chmod 400 your-key.pem

# Connect
ssh -i your-key.pem ubuntu@your-ec2-public-ip

Step 3: Install Python and Dependencies

# Update system
sudo apt update && sudo apt upgrade -y

# Install Python and pip
sudo apt install python3 python3-pip python3-venv nginx -y

# Create app directory
mkdir ~/app && cd ~/app

# Create virtual environment
python3 -m venv venv
source venv/bin/activate

Step 4: Deploy Your FastAPI App

# Upload your app (from local machine)
scp -i your-key.pem -r ./app ubuntu@your-ec2-ip:~/app/

# On the server: install dependencies
pip install fastapi uvicorn gunicorn

Step 5: Configure Gunicorn as a Service

Create /etc/systemd/system/fastapi.service:

[Unit]
Description=FastAPI application
After=network.target

[Service]
User=ubuntu
WorkingDirectory=/home/ubuntu/app
Environment="PATH=/home/ubuntu/app/venv/bin"
ExecStart=/home/ubuntu/app/venv/bin/gunicorn main:app -w 2 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000

[Install]
WantedBy=multi-user.target

sudo systemctl start fastapi
sudo systemctl enable fastapi
sudo systemctl status fastapi

Step 6: Configure Nginx as Reverse Proxy

sudo nano /etc/nginx/sites-available/fastapi

server {
    listen 80;
    server_name your-ec2-public-ip;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

sudo ln -s /etc/nginx/sites-available/fastapi /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Your app is now accessible at http://your-ec2-public-ip.

Option 3: Elastic Beanstalk (Managed PaaS)

AWS Elastic Beanstalk handles the EC2 setup, load balancing, and deployment for you — like hiring a property manager for that apartment instead of doing repairs yourself. It costs more than raw EC2, but removes most of the manual configuration.

pip install awsebcli

In your project directory:

eb init -p python-3.11 my-python-app
eb create my-python-env
eb deploy

Elastic Beanstalk expects a application.py or application callable. For FastAPI:

# application.py
from fastapi import FastAPI
from mangum import Mangum

application = FastAPI()

@application.get("/")
def root():
    return {"status": "ok"}

Option 4: Docker on ECS (Production-Grade)

For production apps, Docker containers running on AWS ECS Fargate are the modern standard — a Docker image is a shipping container that runs identically on your laptop, in CI, and in the cloud, so "it works on my machine" stops being an excuse.

Create a Dockerfile

FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .

EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# Build and push to ECR
aws ecr create-repository --repository-name my-python-app
docker build -t my-python-app .
docker tag my-python-app:latest <account-id>.dkr.ecr.<region>.amazonaws.com/my-python-app:latest
docker push <account-id>.dkr.ecr.<region>.amazonaws.com/my-python-app:latest

Then create an ECS Fargate service from the ECR image in the AWS Console.

Environment Variables and Secrets

Never hardcode secrets in code. Use AWS Systems Manager Parameter Store or Secrets Manager:

import boto3

def get_secret(secret_name: str) -> str:
    client = boto3.client("secretsmanager")
    response = client.get_secret_value(SecretId=secret_name)
    return response["SecretString"]

DATABASE_URL = get_secret("my-app/database-url")

For Lambda and EC2, environment variables are the simpler approach:

import os
DATABASE_URL = os.environ["DATABASE_URL"]

Simpler Alternatives for Beginners

If AWS feels overwhelming, these alternatives are production-ready and developer-friendly:

For building the FastAPI apps you'll deploy, see our FastAPI tutorial. For OOP patterns that make deployed apps maintainable, our Python OOP guide covers the structure large applications need.

Further Reading

• Python Virtual Environments Guide 2026 — venv, pip, and Poetry Explained
• 10 Python Projects That Will Get You a Developer Job
• How I Built a Python Bot That Makes $500/Month Passively
• Python vs JavaScript in 2025: Which Should a Beginner Learn First?
• Python + AI: How to Build Your First Machine Learning Model
• Vector Database Guide: Pinecone, Weaviate, Chroma, and pgvector Compared
• Building Real-Time Apps with WebSockets and React
• Computer Vision Tutorial: Build an Image Classifier from Scratch