Hey Felipe, let's break down why you're hitting that connection limit and fix it up. PythonAnywhere's MySQL plans cap each user at 3 concurrent connections, so even small oversights can trigger this error—let's go through the common gaps you might have missed:

1. Adjust SQLAlchemy Connection Pool Limits #

You set pool_recycle=280 (which is smart, since PythonAnywhere's MySQL timeout is 300s), but the default pool settings might still push you over the 3-connection limit:

• By default, SQLAlchemy uses pool_size=5 (persistent connections kept open) and max_overflow=10 (temporary extra connections). That's way more than your 3-connection cap.
• Update your engine creation to match the limit:

  engine = create_engine(
      SQLALCHEMY_DATABASE_URI,
      pool_recycle=280,
      pool_size=2,  # Keep 2 persistent connections ready
      max_overflow=1  # Allow 1 extra temporary connection (total 3)
  )
  

This ensures your pool never tries to use more than 3 connections at once.

2. Ensure Sessions Are Always Closed (Even When Exceptions Happen) #

Manually calling session.close() works if your code runs without errors, but if an exception is thrown mid-request, that line might never execute—leaking a connection. Switch to using a context manager (with block) to guarantee cleanup:

def listarEmissores():
    with DBSession() as session:
        emissores = session.query(Emissor).all()
        return render_template('listar_emissores.html', emissores=emissores)

The with block automatically handles committing/rolling back and closing the session, no matter what happens in the code inside.

3. Check for Hidden Connection Leaks #

• Global Session Instances: If you created a session = DBSession() variable outside of your request functions (like at the top of a module), that session will stay open permanently, hogging one connection. Make sure all sessions are created inside request handlers or context managers.
• Background/Cron Tasks: If you have scheduled scripts or background jobs running on PythonAnywhere, those also count towards your connection limit. Double-check that those tasks properly close their database sessions too.
• WSGI Worker Reuse: PythonAnywhere uses uWSGI, which reuses worker processes. If your code creates connections outside of request handlers (e.g., in module-level code), those connections might be held open across requests by the worker process.

4. Verify Connection Pool Behavior #

To confirm connections are being recycled properly:

1. Log into your PythonAnywhere MySQL console.
2. Run SHOW PROCESSLIST; to see active and sleeping connections.
3. Look for connections labeled "Sleep"—these should be cleaned up after ~280 seconds (your pool_recycle value). If they linger longer, your pool recycle setting might not be applied correctly.

5. If Using Flask-SQLAlchemy (Not Raw SQLAlchemy) #

If you're using the Flask-SQLAlchemy extension instead of manually creating engines/sessions, make sure you're setting the pool configs in your app's config instead of creating the engine yourself:

app.config['SQLALCHEMY_DATABASE_URI'] = your_db_uri
app.config['SQLALCHEMY_POOL_RECYCLE'] = 280
app.config['SQLALCHEMY_POOL_SIZE'] = 2
app.config['SQLALCHEMY_MAX_OVERFLOW'] = 1

Flask-SQLAlchemy will apply these settings to its internal engine automatically.

After making these changes, restart your PythonAnywhere web app and monitor if the error persists. Most of the time, adjusting the pool size and using context managers fixes this issue!

内容的提问来源于stack exchange，提问作者Felipe V