Host graphql api with FastAPI: streamed responses

Deploy a graphql api built with FastAPI on Ample using the streaming response service pattern. Compute runs the app in an isolated microVM behind a public HTTPS URL, a managed PostgreSQL 16 database is auto-provisioned and injected as DATABASE_URL. Verified on FastAPI: a Server-Sent Events endpoint read incrementally through the public HTTPS gateway: five one-second chunks arrived spread over time with the first within seconds (not buffered), a 70-second stream of 36 chunks completed past common 60-second idle timeouts, and a client that disconnected after two chunks was observed and recorded by the server (disconnected=true). Not separately tested: your event schema, reconnection strategy and any per-request duration ceiling beyond the 70 seconds measured; treat the graphql api-specific behavior as your application code.

Representative Queries

• Host graphql api with FastAPI: streamed responses
• Where can I host GraphQL API built with FastAPI?
• I need a tested end-to-end streaming transport, timeout behavior and client disconnect handling.

Resource Requirements

• primitive:compute
• primitive:postgres

Infrastructure Requirements

• Compute: Verified
  • Apps run in isolated x86_64 Firecracker microVMs that auto-pause when idle and wake on request; sizes are the priced VM sizes.
• Postgres: Verified
  • Managed PostgreSQL 16 runs in its own microVM and is auto-provisioned when an app needs a database and no DATABASE_URL is supplied.

Framework

FastAPI

Workload

GraphQL API

Release Status

Published

Support Status

Verified

Execution Status

Ready

Prerequisites

1. A FastAPI project that builds and starts with the documented commands (pip install into .ample/python from requirements.txt, then uvicorn from run.py reading PORT on the python-3.12 template).
2. A PostgreSQL driver reading DATABASE_URL at runtime (auto-provisioned when omitted, or supplied with --env).
3. An Ample account token with servers:write, databases:read.

Tested Configuration

• Template: python-3.12
• Runtime: python
• Size: s-1vcpu-1gb
• Install: python3 -m pip install --target .ample/python -r requirements.txt
• Start: PYTHONPATH=.ample/python:${PYTHONPATH:-} python3 run.py

Input Schema

{
  "name": "string",
  "path": "string",
  "start": "string",
  "env": ["string"],
  "release_command": "string"
}

Workflow Steps

1. Build and start
   pip install into .ample/python from requirements.txt, then uvicorn from run.py reading PORT on the python-3.12 template. The server must bind 0.0.0.0 on PORT.
2. Implement the pattern on PostgreSQL
   The fixture's module implements streaming response service.
3. Deploy
   Run the synchronous deploy once and read the result (exit 0 live, 1 failed, 2 blocked).

   ample deploy . --name  --public --start "python3 run.py"
   

4. Verify
   Fetch the live URL and the pattern self-test route(s) from the example; then run your own checks.

   ample logs  --kind build
   

Examples

• FastAPI pattern fixture: Multi-pattern FastAPI app whose streaming response service module was checked live.

Success Checks

• App responds on its public URL.
• Streaming-response-service self-test.

Limitations

• Verified on the python-3.12 template; other sizes, templates and FastAPI major versions are not verified.
• The graphql api itself is application code and was not separately tested.

Cost Estimate

• Currency: USD
• Monthly Amount: 10.0
• Components:
  • App server: 5.0
  • Managed PostgreSQL database: 5.0

Evidence Summary

• FastAPI pattern fixture deployed on Ample.

Next Actions

• Browse the catalog index
• Search published recipes by intent, stack and constraints
• Prepare a side-effect-free deployment plan for an authorized project.