224 lines
5.8 KiB
Go
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
|
|
}
|