基于CLI的Golang程序转Heroku GUI：AWS S3文件读取求助

Hey there! Let's get your Go app hooked up to AWS S3 so you can ditch the local domains.txt file and run it smoothly as a GUI on Heroku. Here's a step-by-step breakdown with code examples tailored to your use case:

1. Set Up the AWS SDK for Go v2 #

First, you'll need the latest AWS SDK (v2 is preferred over v1 now). Install the required packages:

go get github.com/aws/aws-sdk-go-v2/aws
go get github.com/aws/aws-sdk-go-v2/config
go get github.com/aws/aws-sdk-go-v2/service/s3

2. Configure AWS Credentials on Heroku #

Heroku lets you set environment variables for sensitive data—no hardcoding credentials! Run these commands in your terminal:

heroku config:set AWS_ACCESS_KEY_ID=your-access-key
heroku config:set AWS_SECRET_ACCESS_KEY=your-secret-key
heroku config:set AWS_REGION=your-s3-bucket-region # e.g., us-east-1
heroku config:set S3_BUCKET_NAME=your-bucket-name
heroku config:set S3_FILE_KEY=domains.txt # or whatever your file is named in S3

3. Write the S3 File Reading Logic #

Add this function to your codebase to fetch the file content from S3:

import (
    "context"
    "fmt"
    "io"
    "os"

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

// GetS3FileContent fetches the content of a file from your S3 bucket
func GetS3FileContent() (string, error) {
    // Load AWS config from environment variables
    cfg, err := config.LoadDefaultConfig(context.TODO(),
        config.WithRegion(os.Getenv("AWS_REGION")),
    )
    if err != nil {
        return "", fmt.Errorf("unable to load SDK config: %v", err)
    }

    // Create S3 client
    client := s3.NewFromConfig(cfg)

    // Fetch the object from S3
    bucket := os.Getenv("S3_BUCKET_NAME")
    key := os.Getenv("S3_FILE_KEY")
    resp, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
        Bucket: aws.String(bucket),
        Key:    aws.String(key),
    })
    if err != nil {
        return "", fmt.Errorf("failed to get S3 object: %v", err)
    }
    defer resp.Body.Close()

    // Read the body into a string
    content, err := io.ReadAll(resp.Body)
    if err != nil {
        return "", fmt.Errorf("failed to read S3 object body: %v", err)
    }

    return string(content), nil
}

4. Replace Local File Read with S3 Fetch #

Now update your getdomains() and process() functions to use the S3 content instead of domains.txt. For example, if your original code looked like this:

func getdomains() ([]string, error) {
    content, err := os.ReadFile("domains.txt")
    if err != nil {
        return nil, err
    }
    // Split content into lines (assuming one domain per line)
    return strings.Split(string(content), "\n"), nil
}

Modify it to use the S3 function:

import "strings"

func getdomains() ([]string, error) {
    content, err := GetS3FileContent()
    if err != nil {
        return nil, err
    }
    // Split into lines, filter out empty lines
    domains := strings.Split(content, "\n")
    filtered := make([]string, 0, len(domains))
    for _, d := range domains {
        if strings.TrimSpace(d) != "" {
            filtered = append(filtered, strings.TrimSpace(d))
        }
    }
    return filtered, nil
}

Then your process() function can use the domains slice from getdomains() just like before—no other changes needed!

5. Heroku GUI App Tips #

Since you're moving to a GUI (web app) on Heroku:

• Use a lightweight Go web framework like Gin or Echo to serve your GUI.
• Make sure your app listens on the port provided by Heroku's PORT environment variable:

  port := os.Getenv("PORT")
  if port == "" {
      port = "8080" // fallback for local testing
  }
  log.Fatal(http.ListenAndServe(":"+port, router))
  

• Ensure your Heroku Procfile is set up correctly to run your web app:

  web: ./your-app-binary-name
  

That's it! Your app will now pull the domain list directly from S3 instead of relying on a local file, making it fully compatible with Heroku's ephemeral filesystem.

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