Building a Production-Ready Text-to-Text API with AWS Bedrock, Lambda & API Gateway

Source: Dev.to – Building a Production‑Ready Text‑to‑Text API with AWS Bedrock, Lambda & API Gateway

Project Overview

This project demonstrates how to design and deploy a production‑ready text‑to‑text AI API using AWS Bedrock and Amazon Titan Text, exposed securely via Amazon API Gateway and powered by AWS Lambda.

The goal is to show how organizations can integrate generative‑AI capabilities into real business systems while maintaining:

• Security
• Scalability
• Cost control
• Observability

Business Use Case

Many organizations want to leverage generative AI for:

• Internal copilots
• Automated content generation
• Text summarisation
• Data explanations
• Customer‑support automation

Directly exposing foundation models to applications can introduce security, cost, and governance risks.

This project solves that by:

1. Abstracting the foundation model behind a controlled API.
2. Enforcing consistent prompts and parameters.
3. Centralising access, logging, and cost management.

The result is a secure AI service layer that can be reused across multiple teams and applications.

Architecture Overview

Flow

1. Client – Sends text input to an API endpoint.
2. API Gateway – Validates and routes the request.
3. Lambda – Processes the request and invokes AWS Bedrock.
4. Amazon Titan – Generates a text response.
5. Client – Receives the response.

🛠️ Tools & Services Used

🧠 Why This Design Matters

• Stateless AI calls – foundation models do not retain memory.
• Explicit control – prompts and parameters are centrally managed.
• Security‑first – IAM‑controlled access to Bedrock.
• Cost management – token limits and model choice are enforced.
• Reusability – multiple applications can consume the same API.

This mirrors how AI platforms are built in regulated and enterprise environments.

🧩 AWS Lambda: Text‑to‑Text Processing Logic

This example shows a Python AWS Lambda function that:

1. Receives text from API Gateway.
2. Calls Amazon Bedrock (Titan Text model).
3. Returns the generated response.

The Lambda acts as a controlled AI‑service layer between your applications and the foundation model.

1. Create the Lambda Function

2. Add the Function Code

Replace the default code with the implementation from the GitHub repository.

import json
import boto3
import os

# Initialise Bedrock client
bedrock = boto3.client(
    "bedrock-runtime",
    region_name=os.getenv("AWS_REGION")
)

def lambda_handler(event, context):
    """Handle API‑Gateway request, invoke Titan Text, and return the result."""
    # 1️⃣ Extract the text payload from the request body
    body = json.loads(event.get("body", "{}"))
    user_input = body.get("input", "")

    if not user_input:
        return {
            "statusCode": 400,
            "body": json.dumps({"error": "Missing 'input' in request body"})
        }

    # 2️⃣ Build the request payload for Titan Text
    payload = {
        "prompt": user_input,
        "temperature": 0.0,
        "maxTokens": 1024,
        "topP": 0.9,
        "stopSequences": []
    }

    # 3️⃣ Invoke the model
    try:
        response = bedrock.invoke_model(
            body=json.dumps(payload).encode("utf-8"),
            modelId="amazon.titan-text-express-v1",
            contentType="application/json",
            accept="application/json"
        )
        result = json.loads(response["body"].read())
        generated_text = result.get("completion", "")

        return {
            "statusCode": 200,
            "body": json.dumps({"output": generated_text})
        }

    # 4️⃣ Error handling
    except Exception as e:
        print(f"Error invoking Bedrock: {e}")
        return {
            "statusCode": 500,
            "body": json.dumps({"error": "Internal server error"})
        }

3. Adjust Lambda Settings

Now the Lambda is ready to receive text via API Gateway, forward it to Amazon Titan Text, and return the generated output. 🎉

🔐 Required IAM Permissions

The Lambda execution role must be allowed to invoke Bedrock models. (Lambda already has permission to write logs to CloudWatch.)

1. In the Lambda console, go to Configuration → Permissions.
2. Click the Role name to open the IAM role.
3. Attach the following inline policy (or add it to an existing policy):

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowInvokeTitanText",
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel"
      ],
      "Resource": [
        "arn:aws:bedrock:*:*:model/amazon.titan-text-express-v1"
      ]
    }
  ]
}

Tip: If you plan to use additional Bedrock models, add their ARNs to the Resource array.

📡 Expose the Lambda via API Gateway

1. Create a new API – In API Gateway, choose REST API (or HTTP API for a lighter footprint).
2. Add a POST method – Create a /generate resource and add a POST method.
3. Configure the integration – Set Integration type to Lambda Function and select the Lambda you created.
4. Enable CORS (if the API will be called from browsers).
5. (Optional) Attach an authorizer – e.g., Cognito, JWT, etc., to enforce authentication.
6. Deploy the API – Deploy to a stage (e.g., prod).

🚀 Test the End‑to‑End Flow

curl -X POST https://<api-id>.execute-api.<region>.amazonaws.com/prod/generate \
  -H "Content-Type: application/json" \
  -d '{"input":"Explain the benefits of serverless architectures in 2 sentences."}'

Expected JSON response

{
  "output": "Serverless architectures eliminate the need to manage infrastructure, allowing developers to focus on code. They also provide automatic scaling and pay‑as‑you‑go pricing, reducing operational costs."
}

📚 Further Reading & Resources

• AWS Bedrock Documentation – https://docs.aws.amazon.com/bedrock/
• Amazon Titan Text Model Card – https://aws.amazon.com/bedrock/titan-text/
• Best Practices for Serverless APIs – https://aws.amazon.com/blogs/compute/best-practices-for-building-serverless-apis/

{
  "Resource": [
    "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-text-express-v1"
  ]
}

🌐 API Gateway Request Example

1. Create API – In the API Gateway console click Create API → REST API → Build.

   

2. Create a resource – In Resources click Create resource, enter a name, and create it.

   

3. Create a method – Click Create Method, select POST, choose Lambda function integration, enable Lambda proxy integration, and select your Lambda.

   

4. Deploy the API – Click Deploy API, create a new stage, name it, and deploy.

   

5. Copy the Invoke URL – On the Stage details page, copy the Invoke URL and test with any client (e.g., Postman).

   

Test Request (Postman)

POST https://05q0if5orb.execute-api.us-east-1.amazonaws.com/prod/text
Content-Type: application/json

{
  "text": "what is Amazon Bedrock"
}

✅ API Response Example

{
  "response": "\nAmazon Bedrock is the name of AWS’s managed service for managing the underlying infrastructure that powers your intelligent bot. It is a collection of services that you can use to build, deploy, and scale intelligent bots at scale. Amazon Bedrock is a managed service that makes foundation models from leading AI startup and Amazon’s own Titan models available through APIs. For up‑to‑date information on Amazon Bedrock and how 3P models are approved, endorsed or selected please see the provided documentation and relevant FAQs."
}

🧠 Why This Lambda Design Matters

• Keeps foundation models behind a secure API.
• Enforces consistent parameters (temperature, token limits).
• Prevents direct client access to Bedrock.
• Enables logging, monitoring, and governance.

This pattern is commonly used to build enterprise AI platforms.

📦 Example Use Cases

• Text summarization API
• AI‑powered content generation service
• Analytics explanation engine
• Internal AI assistant backend
• Secure GenAI microservice