Build Your Own AI Image Generation Website: A Step-by-Step Guide

Want to build your own image generation website? This guide shows you how to leverage the power of Amazon Bedrock, AWS Lambda, and other AWS services to create stunning AI-generated images from text prompts. Learn how to create custom visuals quickly and affordably, even if you’re on a budget using Amazon Bedrock image generation.

This solution is perfect for IT professionals, AWS Community Builders, and GenAI enthusiasts eager to explore AI-powered image creation. We'll walk through the entire process, ensuring you can integrate this technology into your projects. Get ready to build a functional website generating images from text using Amazon Nova Canvas.

Why Build an AI Image Generation Website?

• Automate Visual Content Creation: Generate unique images on demand, saving time and resources.
• Cost-Effective Image Generation: Using Amazon Nova Canvas, produce high-quality visuals without expensive design tools or subscriptions.
• Explore Generative AI: Dive into the world of AI and understand how these models can be applied to real-world scenarios.

Real-World Use Case: Streamlining Digital Marketing Campaigns in India, Create Images Faster

Before generative AI, digital marketing companies relied on graphic designers or stock images, a slow, iterative process. Now, with Amazon Bedrock, digital marketers can instantly generate custom visuals by simply describing what they need. This saves time and allows for posting timely, relevant content without delays.

Scenario: During festivals, businesses in India actively engage in promotional campaigns. Manually creating festive greetings for social media platforms with branding takes hours.

AI Solution: With a GenAI-powered image generator, input a prompt describing the client's background and the festival theme. In seconds, you get a ready-to-use image. What once took hours now takes minutes, all thanks to the speed and efficiency of Amazon Nova Canvas.

Architecture Overview: How It Works

Here's a breakdown of the architecture:

1. User Interaction: Users input prompts on a static website hosted on Amazon S3.
2. API Gateway: The prompt is routed through API Gateway to trigger an AWS Lambda function.
3. Lambda Function: This function communicates with Amazon Bedrock, using the Amazon Nova Canvas model to generate images.
4. Image Storage: Generated images are securely stored in an S3 bucket.
5. Secure Access: The Lambda function creates a pre-signed URL, providing time-limited access for viewing and downloading the image.

This architecture ensures ease of use and security, offering a professional and secure image generation service.

Understanding Amazon Nova Pricing

Amazon Nova offers transparent pricing for image generation models.

• Pricing is based on image resolution and quality.
• Amazon Nova Canvas: Up to 1024 x 1024 resolution at standard quality costs $0.04 per image.

Important: Always verify the latest pricing on the official AWS Bedrock Pricing page.

Prerequisites

• AWS Account with admin/IAM access
• IAM Roles/Policies for Lambda, S3, API Gateway, Bedrock
• S3 Bucket for static website hosting
• Lambda & API Gateway integration
• AWS Bedrock enabled in your region
• Basic AWS Console navigation skills
• Awareness of costs for Lambda, API Gateway, S3, Bedrock

Getting Access to Amazon Nova via Amazon Bedrock

1. Go to AWS Console: Navigate to Amazon Bedrock Service.
2. Request Access: If it's your first time, request access, especially if you're in a limited preview region. Make sure you're in a supported AWS region (e.g., us-east-1).
3. Enable Bedrock: Open the Bedrock console, select "Model access," and request access to Amazon Nova Foundation Model.
4. Get API Details:
   • Click "Foundation models."
   • Search or filter by Provider = Amazon and Model = Nova.
   • Click the model name to view details, including the Model ID (required for API calls).

Deconstructing the Lambda Code

The Lambda function generates an image, stores it in S3, and returns a temporary shareable link.

1. Import Libraries & Initialize S3:
   • Imports necessary libraries (json, boto3, base64, datetime).
   • Initializes the S3 client and defines your S3 bucket name.
2. Define Handler & Read Prompt:
   • Looks for a prompt in the incoming request; uses a default ("The cat on beach") if none is provided.
3. Prepare Bedrock API Call:
   • Configures the API call using the Nova Canvas model, passing the prompt and settings like image size and quality.
4. Decode Image Data:
   • Decodes the base64-encoded image data from the Bedrock API.
5. Create Unique Filename:
   • Generates a unique filename using the prompt and timestamp.
6. Upload to S3:
   • Uploads the image to the specified S3 bucket.
7. Return Pre-Signed URL:
   • Generates a temporary (1-hour validity) URL to access and preview the image.

Complete Lambda Code (Python):

import json
import boto3
import base64
from datetime import datetime

s3 = boto3.client("s3")
BUCKET_NAME = "your-s3-bucket-name"  # Replace with your S3 bucket name

def lambda_handler(event, context):
    # Store the input data (prompt)
    input_prompt = event.get('prompt', 'The cat on beach')
    print(f"Input Prompt: {input_prompt}")

    bedrock_rtime = boto3.client("bedrock-runtime", region_name="us-east-1")
    kwargs = {
        "modelId": "amazon.nova-canvas-v1:0",
        "contentType": "application/json",
        "accept": "application/json",
        "body": json.dumps({
            "textToImageParams": {"text": input_prompt},
            "taskType": "TEXT_IMAGE",
            "imageGenerationConfig": {
                "cfgScale": 8,
                "seed": int(datetime.now().timestamp()) % 100000,
                "quality": "standard",
                "width": 1280,
                "height": 720,
                "numberOfImages": 1
            }
        })
    }

    response = bedrock_rtime.invoke_model(**kwargs)
    response_body = json.loads(response.get('body').read())
    # Extract the single image
    image_data = response_body["images"][0]
    image_bytes = base64.b64decode(image_data)
    # Generate a unique filename with timestamp
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    sanitized_prompt = input_prompt.replace(" ", "_").replace(":", "").replace("/", "").replace("\\", "")[:50]
    image_key = f"generated_images/{sanitized_prompt}_{timestamp}.png"
    # Upload to S3
    s3.put_object(
        Bucket=BUCKET_NAME,
        Key=image_key,
        Body=image_bytes,
        ContentType="image/png"
    )
    # Generate a pre-signed URL (valid for 1 hour)
    presigned_url = s3.generate_presigned_url(
        "get_object",
        Params={"Bucket": BUCKET_NAME, "Key": image_key},
        ExpiresIn=3600
    )
    return {
        "statusCode": 200,
        "body": json.dumps(presigned_url)
    }

Configuring Your Lambda Function

1. Create an S3 Bucket: Before creating the function, create an S3 bucket to store AI-generated images. Replace 'your-s3-bucket-name' in the Lambda function code with your bucket name to ensure that generated images are stored where they should be.
2. Create the Lambda Function:
   • Go to the AWS Lambda Console and click "Create function."
   • Choose "Author from scratch."
   • Function name: genai-image-generator
   • Runtime: Python 3.12 (or the latest version)
   • Click "Create function."
3. Upload the Code:
   • Scroll to the "Function code" section and paste the Python code.
   • Click "Deploy."
4. Set Up IAM Permissions:
   • Go to "Configuration" -> "Permissions."
   • Click on the role name under "Execution role."
   • Add permissions, attaching "AmazonS3FullAccess" and "AmazonBedrockFullAccess" policies.
5. Increase Lambda Timeout:
   • Go to "Configuration" -> "General configuration."
   • Set "Timeout" to 5 minutes (00:05:00).
   • Click "Save."
6. Test Your Function:
   • Click the "Test" button.
   • Create a new test event with the following input:

{
    "prompt": "A futuristic city with flying cars at sunset"
}

• Click "Test" again. A successful run returns a "statusCode": 200 and a pre-signed S3 URL.

This guide provides a comprehensive path to building your own AI image generation website using Amazon Bedrock and other AWS services. By following these steps, you'll be well on your way to creating a powerful tool for generating custom visuals with ease.