Files
mtusi2026lab4/cmd/s3init/main.go
T

224 lines
5.8 KiB
Go

// Command s3init bootstraps the private attachment bucket. It is idempotent:
// it runs before the API on every compose up, verifies the bucket and the
// application identity, and exits successfully when everything is in place.
package main
import (
"bytes"
"context"
"errors"
"fmt"
"log/slog"
"os"
"strings"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/credentials"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/smithy-go"
"github.com/google/uuid"
)
const bootstrapTimeout = 120 * time.Second
type settings struct {
Endpoint string
Region string
Bucket string
AdminAccessKey string
AdminSecretKey string
AppAccessKey string
AppSecretKey string
}
func main() {
log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
if err := run(log); err != nil {
log.Error("s3 bootstrap failed", slog.Any("error", err))
os.Exit(1)
}
}
func run(log *slog.Logger) error {
cfg, err := loadSettings()
if err != nil {
return err
}
ctx, cancel := context.WithTimeout(context.Background(), bootstrapTimeout)
defer cancel()
admin := newClient(cfg, cfg.AdminAccessKey, cfg.AdminSecretKey)
app := newClient(cfg, cfg.AppAccessKey, cfg.AppSecretKey)
if err := waitForBucket(ctx, admin, cfg.Bucket); err != nil {
return err
}
if err := probeAppIdentity(ctx, app, cfg.Bucket); err != nil {
return err
}
if err := probeForbiddenPrefix(ctx, app, cfg.Bucket); err != nil {
return err
}
log.Info("s3 bucket ready",
slog.String("endpoint", cfg.Endpoint),
slog.String("bucket", cfg.Bucket),
)
return nil
}
func loadSettings() (settings, error) {
cfg := settings{
Endpoint: strings.TrimSpace(os.Getenv("S3_ENDPOINT")),
Region: strings.TrimSpace(os.Getenv("S3_REGION")),
Bucket: strings.TrimSpace(os.Getenv("S3_BUCKET")),
AdminAccessKey: strings.TrimSpace(os.Getenv("S3_ADMIN_ACCESS_KEY")),
AdminSecretKey: strings.TrimSpace(os.Getenv("S3_ADMIN_SECRET_ACCESS_KEY")),
AppAccessKey: strings.TrimSpace(os.Getenv("S3_ACCESS_KEY_ID")),
AppSecretKey: strings.TrimSpace(os.Getenv("S3_SECRET_ACCESS_KEY")),
}
switch {
case cfg.Endpoint == "":
return settings{}, errors.New("S3_ENDPOINT is required")
case cfg.Region == "":
return settings{}, errors.New("S3_REGION is required")
case cfg.Bucket == "":
return settings{}, errors.New("S3_BUCKET is required")
case cfg.AdminAccessKey == "" || cfg.AdminSecretKey == "":
return settings{}, errors.New("S3_ADMIN_ACCESS_KEY and S3_ADMIN_SECRET_ACCESS_KEY are required")
case cfg.AppAccessKey == "" || cfg.AppSecretKey == "":
return settings{}, errors.New("S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY are required")
}
return cfg, nil
}
func newClient(cfg settings, accessKey, secretKey string) *s3.Client {
return s3.New(s3.Options{
Region: cfg.Region,
BaseEndpoint: aws.String(cfg.Endpoint),
UsePathStyle: true,
Credentials: credentials.NewStaticCredentialsProvider(accessKey, secretKey, ""),
})
}
func waitForBucket(ctx context.Context, client *s3.Client, bucket string) error {
for {
_, err := client.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: aws.String(bucket)})
if err == nil {
return nil
}
if !isNotFound(err) {
return fmt.Errorf("head bucket: %w", err)
}
if _, err := client.CreateBucket(ctx, &s3.CreateBucketInput{Bucket: aws.String(bucket)}); err == nil {
return nil
} else if isBucketExists(err) {
return nil
} else if !isNotFound(err) {
return fmt.Errorf("create bucket: %w", err)
}
select {
case <-ctx.Done():
return fmt.Errorf("wait for object store: %w", ctx.Err())
case <-time.After(time.Second):
}
}
}
func probeAppIdentity(ctx context.Context, client *s3.Client, bucket string) error {
key := "staging/.bootstrap/" + uuid.NewString()
if _, err := client.PutObject(ctx, &s3.PutObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
Body: bytes.NewReader([]byte("ok")),
ContentLength: aws.Int64(2),
ContentType: aws.String("text/plain"),
}); err != nil {
return fmt.Errorf("application identity cannot write: %w", err)
}
defer func() {
_, _ = client.DeleteObject(ctx, &s3.DeleteObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
})
}()
if _, err := client.HeadObject(ctx, &s3.HeadObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
}); err != nil {
return fmt.Errorf("application identity cannot read: %w", err)
}
if _, err := client.ListObjectsV2(ctx, &s3.ListObjectsV2Input{
Bucket: aws.String(bucket),
Prefix: aws.String("staging/"),
}); err != nil {
return fmt.Errorf("application identity cannot list: %w", err)
}
return nil
}
func probeForbiddenPrefix(ctx context.Context, client *s3.Client, bucket string) error {
key := "forbidden/" + uuid.NewString()
_, err := client.PutObject(ctx, &s3.PutObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
Body: bytes.NewReader([]byte("must not be stored")),
})
if err == nil {
_, _ = client.DeleteObject(ctx, &s3.DeleteObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
})
return errors.New("application identity can write outside the allowed prefixes; check infra/s3/s3.json")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) || apiErr.ErrorCode() != "AccessDenied" {
return fmt.Errorf("forbidden-prefix probe returned an unexpected error: %w", err)
}
return nil
}
func isNotFound(err error) bool {
var apiErr smithy.APIError
if errors.As(err, &apiErr) {
switch apiErr.ErrorCode() {
case "NotFound", "NoSuchBucket", "NoSuchKey":
return true
}
}
return false
}
func isBucketExists(err error) bool {
var apiErr smithy.APIError
if errors.As(err, &apiErr) {
switch apiErr.ErrorCode() {
case "BucketAlreadyExists", "BucketAlreadyOwnedByYou":
return true
}
}
return false
}