使用生成式 AI 自动创建社交媒体图像

PromptPreparationAPIFunction:
  Type: AWS::Serverless::Function
  Properties:
    Handler: bootstrap
    Runtime: provided.al2023
    CodeUri: prepare-prompt/
    Timeout: 30
    Policies:
      - AWSLambdaBasicExecutionRole
      - Version: "2012-10-17"
        Statement:
          - Effect: "Allow"
            Action:
              - comprehend:DetectSentiment
              - comprehend:DetectKeyPhrases
            Resource: "*"

DalleImageGenerationFunction:
  Type: AWS::Serverless::Function
  Properties:
    Handler: bootstrap
    Runtime: provided.al2023
    CodeUri: generate-image-dalle/
    Timeout: 30
    Environment:
      Variables:
        OPENAI_API_KEY: !Ref OpenAIApiKey
    Policies:
      - AWSLambdaBasicExecutionRole

BedrockImageGenerationFunction:
  Type: AWS::Serverless::Function
  Properties:
    Handler: bootstrap
    Runtime: provided.al2023
    CodeUri: generate-image-bedrock/
    Timeout: 30
    Environment:
      Variables:
        BUCKET_NAME: !Ref ImageUploadBucket
    Policies:
      - AWSLambdaBasicExecutionRole
      - Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Action:
              - "bedrock:InvokeModel"
            Resource: "*"

ImageUploadFunction:
  Type: AWS::Serverless::Function
  Properties:
    Handler: bootstrap
    Runtime: provided.al2023
    CodeUri: upload-image/
    Timeout: 30
    Environment:
      Variables:
        BUCKET_NAME: !Ref ImageUploadBucket
        REGION: !Ref AWS::Region
    Policies:
      - AWSLambdaBasicExecutionRole

GetImageFunction:
  Type: AWS::Serverless::Function
  Properties:
    Handler: bootstrap
    Runtime: provided.al2023
    CodeUri: get-image/
    Timeout: 30
    Environment:
      Variables:
        BUCKET_NAME: !Ref ImageUploadBucket
    Policies:
      - AWSLambdaBasicExecutionRole

package main

import (
	"context"
	"fmt"
	"log"
  "strings"

	"github.com/aws/aws-lambda-go/lambda"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/comprehend"
)

type InputEvent struct {
	Detail struct {
		Text  string `json:"text"`
		S3Key string `json:"s3Key"`
		Bedrock bool `json:"bedrock"`
	} `json:"detail"`
}

type OutputEvent struct {
	Prompt string `json:"prompt"`
	S3Key  string `json:"s3Key"`
	Bedrock bool `json:"bedrock"`
}

// function to get the top sentiment and convert it for the prompt
func getTopSentiment(sentimentScores *comprehend.SentimentScore) string {
	sentiments := map[string]float64{
		"Positive": *sentimentScores.Positive,
		"Negative": *sentimentScores.Negative,
		"Neutral":  *sentimentScores.Neutral,
		"Mixed":    *sentimentScores.Mixed,
	}

	var topSentiment string
	var maxScore float64

	for sentiment, score := range sentiments {
		if score > maxScore {
			maxScore = score
			topSentiment = sentiment
		}
	}

	switch topSentiment {
	case "Positive":
		topSentiment = "happy"
	case "Negative":
		topSentiment = "sad"
	case "Neutral":
		fallthrough
	case "Mixed":
		topSentiment = "neutral"
	}

	return topSentiment
}

func handler(ctx context.Context, event InputEvent) (OutputEvent, error) {
	text := event.Detail.Text
  // creating a new session for comprehend and forcing eu west 1 as regions since its not available in the eu north 1 region
	svc := comprehend.New(session.Must(session.NewSession(&aws.Config{
		Region: aws.String("eu-west-1"),
	})))

  // Preparing the parameters to be sent to comprehend
	sentimentParams := &comprehend.DetectSentimentInput{
		Text:         aws.String(text),
		LanguageCode: aws.String("en"),
	}

  keyPhraseParams := &comprehend.DetectKeyPhrasesInput{
  Text:         aws.String(text),
  LanguageCode: aws.String("en"),
	}

  // Detecting the sentiment of the provided text
	sentimentResult, err := svc.DetectSentiment(sentimentParams)
	if err != nil {
		return OutputEvent{}, fmt.Errorf("failed to detect sentiment: %w", err)
	}

	keyPhraseResult, err := svc.DetectKeyPhrases(keyPhraseParams)
	if err != nil {
		return OutputEvent{}, fmt.Errorf("failed to process text: %w", err)
	}

	var keyPhrases []string
  // Getting the top sentiment
	topSentiment := getTopSentiment(sentimentResult.SentimentScore)
  // start the phrases array with the emotion
  keyPhrases = append(keyPhrases, topSentiment)
  // append all phrases to string array
	for _, phrase := range keyPhraseResult.KeyPhrases {
    keyPhrases = append(keyPhrases, *phrase.Text)
	}
  // create a string from the key words
	summary := strings.Join(keyPhrases, " ")

  // Creating the prompt to be used for image generation
	prompt := fmt.Sprintf("Generate a image based on the following key words: %s",  summary)

  // Creating the output and returning to the next function
	outputEvent := OutputEvent{Prompt: prompt, S3Key: event.Detail.S3Key, Bedrock: event.Detail.Bedrock}

	return outputEvent, nil
}

func main() {
	lambda.Start(handler)
}

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"

	"github.com/aws/aws-lambda-go/lambda"
)

type InputEvent struct {
	Prompt string `json:"prompt"`
	S3Key  string `json:"s3Key"`
}

type OutputEvent struct {
	Url   string `json:"url"`
	S3Key string `json:"s3Key"`
}

// Type for how the request to DALL-E should be structured
type DalleRequest struct {
	Model  string `json:"model"`
	Prompt string `json:"prompt"`
	Size   string `json:"size"`
	N      int    `json:"n"`
}

// Type for how the request response is structured
type ResponseObject struct {
	Data []struct {
		Url string `json:"url"`
	} `json:"data"`
}

func handler(ctx context.Context, event InputEvent) (OutputEvent, error) {
  // Grabbing our api-key from the environment variable
	openaiApiKey := os.Getenv("OPENAI_API_KEY")
	if openaiApiKey == "" {
		log.Println("Error: OPENAI_API_KEY environment variable is not set")
		return OutputEvent{}, fmt.Errorf("missing OPENAI_API_KEY")
	}

  // Preparing the DALL-E request
	requestBody := DalleRequest{
		Model:  "dall-e-3",
		Prompt: event.Prompt,
		Size:   "1024x1024",
		N:      1,
	}

  // preparing the payload for the request
	payload, err := json.Marshal(requestBody)
	if err != nil {
		log.Println("Error marshalling data:", err)
		return OutputEvent{}, err
	}

  // creating request
	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://api.openai.com/v1/images/generations", bytes.NewBuffer(payload))
	if err != nil {
		log.Println("Error creating request:", err)
		return OutputEvent{}, err
	}

  // Setting headers for the request
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", openaiApiKey))

  // sending request to openAI
	resp, err := client.Do(req)
	if err != nil {
		log.Println("Error sending request:", err)
		return OutputEvent{}, err
	}
	defer resp.Body.Close()

  // Reading all data from the response
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Println("Error reading response body:", err)
		return OutputEvent{}, err
	}
  // If the response is not of status OK an error is returned
	if resp.StatusCode != http.StatusOK {
		log.Printf("Non-OK HTTP status: %s\nResponse body: %s\n", resp.Status, string(body))
		return OutputEvent{}, fmt.Errorf("non-OK HTTP status: %s", resp.Status)
	}

  // Un-marshalling the response
	var respData ResponseObject
	err = json.Unmarshal(body, &respData)
	if err != nil {
		log.Println("Error unmarshalling response:", err)
		return OutputEvent{}, err
	}

	if len(respData.Data) == 0 {
		log.Println("No data received in the response")
		return OutputEvent{}, fmt.Errorf("no data in the response")
	}

  // Extracting the URL for the image
	imageURL := respData.Data[0].Url

  // Creating the output and returning to the next function
	outputEvent := OutputEvent{Url: imageURL, S3Key: event.S3Key}

	return outputEvent, nil
}

func main() {
	lambda.Start(handler)
}

package main

import (
	"bytes"
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/aws/aws-lambda-go/lambda"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/s3"
)

type InputEvent struct {
	Prompt string `json:"prompt"`
	S3Key  string `json:"s3Key"`
}

type OutputEvent struct {
	Url   string `json:"url"`
}

// Titan specific types for requests towards bedrock
type TitanInputTextToImageInput struct {
	TaskType              string                                                `json:"taskType"`
	ImageGenerationConfig TitanInputTextToImageConfig `json:"imageGenerationConfig"`
	TextToImageParams     TitanInputTextToImageParams     `json:"textToImageParams"`
}

type TitanInputTextToImageParams struct {
	Text         string `json:"text"`
	NegativeText string `json:"negativeText,omitempty"`
}

type TitanInputTextToImageConfig struct {
	NumberOfImages int     `json:"numberOfImages,omitempty"`
	Height         int     `json:"height,omitempty"`
	Width          int     `json:"width,omitempty"`
	Scale          float64 `json:"cfgScale,omitempty"`
	Seed           int     `json:"seed,omitempty"`
}

type TitanInputTextToImageOutput struct {
	Images []string `json:"images"`
	Error  string   `json:"error"`
}

// Function to decode base64 image
func decodeImage(base64Image string) ([]byte, error) {
	decoded, err := base64.StdEncoding.DecodeString(base64Image)
	if err != nil {
		return nil, err
	}
	return decoded, nil
}

func handler(ctx context.Context, event InputEvent)  error {
	// Grabbing the name of the bucket from the environment variable
	bucketName := os.Getenv("BUCKET_NAME")
	if bucketName == "" {
		log.Println("Error: BUCKET_NAME environment variable is not set")
		return fmt.Errorf("missing BUCKET_NAME")
	}

	// Preparing config for the runtime and forcing us east 1 since its not available in eu north 1
	cfg, err := config.LoadDefaultConfig(context.Background(), config.WithRegion("us-east-1"))
	if err != nil {
		return err
	}

	// Creating the runtime for bedrock
	runtime := bedrockruntime.NewFromConfig(cfg)

	// Preparing the request payload for bedrock
	payload := TitanInputTextToImageInput{
		TaskType: "TEXT_IMAGE",
		TextToImageParams: TitanInputTextToImageParams{
			Text: event.Prompt,
		},
		ImageGenerationConfig: TitanInputTextToImageConfig{
			NumberOfImages: 1,
			Scale: 8.0,
			Height: 1024.0,
			Width: 1024.0,

		},
	}

	payloadString, err := json.Marshal(payload)
	if err != nil {
		return fmt.Errorf("unable to marshal body: %v", err)
	}

	accept := "*/*"
	contentType := "application/json"
	model := "amazon.titan-image-generator-v1"

	// Sending request to bedrock
	resp, err := runtime.InvokeModel(context.TODO(), &bedrockruntime.
	InvokeModelInput{
		Accept:      &accept,
		ModelId:     &model,
		ContentType: &contentType,
		Body:        payloadString,
	})

	if err != nil {
		return fmt.Errorf("error from Bedrock, %v", err)
	}

	var output TitanInputTextToImageOutput

	err = json.Unmarshal(resp.Body, &output)
	if err != nil {
		return fmt.Errorf("unable to unmarshal response from Bedrock: %v", err)
	}
  	// Decoding base64 to be able to upload image to S3
	decoded, err := decodeImage(output.Images[0])
	if err != nil {
		return fmt.Errorf("unable to decode image: %v", err)
	}

  	// Creating a session for S3
	sesh := session.Must(session.NewSession())

	s3Client := s3.New(sesh)

	objectKey := event.S3Key

	// Uploading image to S3
	_, err = s3Client.PutObject(&s3.PutObjectInput{
		Bucket:      aws.String(bucketName),
		Key:         aws.String(objectKey),
		Body:        bytes.NewReader(decoded),
		ContentType: aws.String(http.DetectContentType(decoded)),
	})
	if err != nil {
		log.Println("Error uploading image to S3:", err)
		return err
	}

	log.Println("Successfully uploaded image to S3:", objectKey)

	return  nil
}

func main() {
	lambda.Start(handler)
}

package main

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"

	"github.com/aws/aws-lambda-go/lambda"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/s3"
)

type Event struct {
	Url   string `json:"url"`
	S3Key string `json:"s3Key"`
}

func handler(ctx context.Context, event Event)  error {
	// Grabbing the name of the bucket from the environment variable
	bucketName := os.Getenv("BUCKET_NAME")
	if bucketName == "" {
		log.Println("Error: BUCKET_NAME environment variable is not set")
		return fmt.Errorf("missing BUCKET_NAME")
	}

	region := os.Getenv("REGION")
	if region == "" {
		log.Println("Error: REGION environment variable is not set")
		return fmt.Errorf("missing REGION")
	}

	imageResp, err := http.Get(event.Url)
	if err != nil {
		log.Println("Error downloading image:", err)
		return err
	}
	defer imageResp.Body.Close()

  	// Downloading image from provided URL
	if imageResp.StatusCode != http.StatusOK {
		log.Printf("Error: received non-OK HTTP status when downloading image: %s\n", imageResp.Status)
		return fmt.Errorf("non-OK HTTP status when downloading image: %s", imageResp.Status)
	}

	imageData, err := io.ReadAll(imageResp.Body)
	if err != nil {
		log.Println("Error reading image data:", err)
		return err
	}
	// Creating a session for S3
	sesh := session.Must(session.NewSession())

	s3Client := s3.New(sesh)

	objectKey := event.S3Key
 	 // Uploading image to S3
	_, err = s3Client.PutObject(&s3.PutObjectInput{
		Bucket:      aws.String(bucketName),
		Key:         aws.String(objectKey),
		Body:        bytes.NewReader(imageData),
		ContentType: aws.String(http.DetectContentType(imageData)),
	})
	if err != nil {
		log.Println("Error uploading image to S3:", err)
		return err
	}

	log.Println("Successfully uploaded image to S3:", objectKey)

	return nil
}

func main() {
	lambda.Start(handler)
}

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/s3"
)

func handler(ctx context.Context, request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
  //Grabbing the name of the bucket from the environment variable
	bucketName := os.Getenv("BUCKET_NAME")
	if bucketName == "" {
		log.Println("Error: BUCKET_NAME environment variable is not set")
		return events.APIGatewayProxyResponse{
			StatusCode: 400,
			Body:      "missing BUCKET_NAME",
		},nil
	}

  // Extracting the S3 key
	queryParams := request.QueryStringParameters
	s3Key, exists := queryParams["s3Key"]
	if !exists {
		return events.APIGatewayProxyResponse{
			StatusCode: 400,
			Body:       "Missing query parameter 's3Key'",
		},nil
	}

  // Creating a connection to S3
	sesh := session.Must(session.NewSession())

	s3Client := s3.New(sesh)

	input := &s3.HeadObjectInput{
		Bucket: aws.String(bucketName),
		Key:    aws.String(s3Key),
	}

  // Checking if image exist
	_, err := s3Client.HeadObject(input)
	if err != nil {
		log.Printf(`{"url": "https://%s.s3.eu-north-1.amazonaws.com/%s"}`, bucketName, s3Key)
		log.Println("param:", s3Key)
		log.Println("Error checking if object exists:", err)
    // If it does not exist return 404
		return events.APIGatewayProxyResponse{
			StatusCode: 404,
			Body:       "Object does not exist",
		}, nil
	}

  // If it does exist return url
	return events.APIGatewayProxyResponse{
		StatusCode: 200,
		Body:       fmt.Sprintf(`{"url": "https://%s.s3.eu-north-1.amazonaws.com/%s"}`, bucketName, s3Key),
	}, nil
}

func main() {
	lambda.Start(handler)
}

import React from "react";
import { Button, Flex, Layout, Spin, Image, Switch } from "antd";
import TextArea from "antd/es/input/TextArea";
import { Typography } from "antd";
import { useMutation, useQuery } from "@tanstack/react-query";
import { getImage, sendPost } from "../../utils/api";

const { Paragraph, Text } = Typography;

const { Header, Content } = Layout;

const headerStyle: React.CSSProperties = {
  textAlign: "center",
  color: "#fff",
  height: 64,
  paddingInline: 48,
  lineHeight: "64px",
  backgroundColor: "#00415a",
};

const contentStyle: React.CSSProperties = {
  textAlign: "center",
  minHeight: 120,
  lineHeight: "120px",
  color: "#fff",
  backgroundColor: "#00719c",
};

const layoutStyle = {
  borderRadius: 8,
  overflow: "hidden",
  width: "calc(50% - 8px)",
  maxWidth: "calc(50% - 8px)",
  marginTop: "10vh",
  height: "100%",
};

const textAreaStyle = {
  width: "80%",
  height: "80%",
};

const buttonStyle = {
  width: "80%",
  height: "80%",
  marginBottom: 16,
  backgroundColor: "#009bd6",
};
const paragraphStyle = {
  margin: 10,
};

const textStyle = {
  color: "white",
};

export default function MainContent() {
  const id = "testing";
  const [post, setPost] = React.useState("");
  const [image, setImage] = React.useState("");
  const [refetch, setRefetch] = React.useState(true);
  const [loading, setLoading] = React.useState(false);
  const [bedrock, setBedrock] = React.useState(false);

  // A function to trigger the generation of an image
  const { mutate } = useMutation({
    mutationFn: () => {
      setLoading(true);
      return sendPost("/generate-image", {
        text: post,
        s3Key: `image/${id}`,
        bedrock: bedrock,
      });
    },
  });
  // A function for polling the /get-image endpoint. When status 200 is returned polling stops and image is displayed
  const { data } = useQuery({
    queryKey: ["image"],
    refetchInterval: 3000,
    refetchIntervalInBackground: true,
    enabled: refetch,
    queryFn: async () => {
      const imageData = await getImage("/get-image", { s3Key: `image/${id}` });
      if (imageData.status === 200) {
        setRefetch(false);
        setImage(imageData.data);
        setLoading(false);
      }
      return imageData.data;
    },
  });

  const handlePostChange = (event: React.ChangeEvent<HTMLTextAreaElement>) => {
    setPost(event.target.value);
  };

  const handleBedrockChange = (checked: boolean) => {
    setBedrock(checked);
  };

  return (
    <Spin spinning={loading}>
      <Flex justify="center">
        <Layout style={layoutStyle}>
          <Header style={headerStyle}>Epic Post To Image POC</Header>
          <Content style={contentStyle}>
            <Paragraph style={paragraphStyle}>
              <Text strong style={textStyle}>
                Write a post as you would for a social media platform. Click
                generate to create an image for your post.
              </Text>
              .
            </Paragraph>

            <TextArea
              style={textAreaStyle}
              rows={4}
              placeholder="Write here"
              onChange={handlePostChange}
            />
            <Paragraph style={paragraphStyle}>
              <Text strong style={textStyle}>
                Use Bedrock? (Toggle to use bedrock)
              </Text>

              <Switch onChange={handleBedrockChange} />
            </Paragraph>
            {
              // If the image exist it will be shown
              image && (
                <Image
                  width={"80%"}
                  style={{ marginTop: "10px" }}
                  src={image}
                />
              )
            }
            <Button type="primary" style={buttonStyle} onClick={() => mutate()}>
              Generate
            </Button>
          </Content>
        </Layout>
      </Flex>
    </Spin>
  );
}

import axios from "axios";

const API_URL = process.env.REACT_APP_API_URL;

export async function sendPost(
  url: string,
  data: { text: string; s3Key: string; bedrock: boolean }
): Promise<{ status: number; data: string }> {
  try {
    const response = await axios({
      method: "post",
      url: `${API_URL}${url}`,
      data,
    });

    return {
      status: response.status,
      data: response.data,
    };
  } catch (error: any) {
    return {
      status: error.response?.status || error.status,
      data: error.response,
    };
  }
}

export async function getImage(
  url: string,
  params: { s3Key: string }
): Promise<{ status: number; data: string }> {
  try {
    const response = await axios({
      method: "get",
      url: `${API_URL}${url}`,
      params,
    });

    return {
      status: response.status,
      data: response.data.url,
    };
  } catch (error: any) {
    return {
      status: error.response?.status || error.status,
      data: error.response,
    };
  }
}