PGO를 쉽게 하는 방법이 있을까?

// Storage is an interface that defines the methods that a storage system for golang profiles for PGO can implement.
type Storage interface {
	// SaveProfile saves the profile data to the storage system.
	SaveProfile(ctx context.Context, createdAt time.Time, profile []byte) error
	// GetProfile retrieves the profile data from the storage system.
	GetProfile(ctx context.Context, createdAt time.Time) ([]byte, error)
	// GetProfiles retrieves the profile data from the storage system.
	GetProfiles(ctx context.Context, startedAt, endedAt time.Time) ([][]byte, error)
	// DeleteProfile deletes the profile data from the storage system.
	DeleteProfile(ctx context.Context, createdAt time.Time) error
	// DeleteProfiles deletes the profile data from the storage system.
	DeleteProfiles(ctx context.Context, startedAt, endedAt time.Time) error
}

func (p *Profiler) Run(ctx context.Context) (<-chan error, error) {
	ctx, cancel := context.WithCancel(ctx)
	p.cancelFunc = cancel
	ticker := time.NewTicker(p.interval)

	done := ctx.Done()

	errCh := make(chan error, 32)

	go func() {
		defer ticker.Stop()
		for {
			select {
			case <-done:
				return
			case <-ticker.C:
				go func() {
					now := time.Now()
					pf, err := collectCpuProfile(p.duration)
					if err != nil {
						errCh <- fmt.Errorf("failed to collect CPU profile: %w", err)
						return
					}

					if err := p.storage.SaveProfile(ctx, now, pf); err != nil {
						errCh <- fmt.Errorf("failed to save profile: %w", err)
						return
					}
				}()
			}
		}
	}()

	return errCh, nil
}

func (p *Profiler) GetProfile(ctx context.Context, startedAt, endedAt time.Time) ([]byte, error) {
	rawProfiles, err := p.storage.GetProfiles(ctx, startedAt, endedAt)
	if err != nil {
		return nil, fmt.Errorf("failed to get profiles: %w", err)
	}

	profiles := make([]*profile.Profile, 0, len(rawProfiles))
	for _, rawProfile := range rawProfiles {
		pf, err := profile.ParseData(rawProfile)
		if err != nil {
			return nil, fmt.Errorf("failed to parse profile: %w", err)
		}
		profiles = append(profiles, pf)
	}

	value, err := profile.Merge(profiles)
	if err != nil {
		return nil, fmt.Errorf("failed to merge profiles: %w", err)
	}

	buf := new(bytes.Buffer)
	if err := value.Write(buf); err != nil {
		return nil, fmt.Errorf("failed to write profile: %w", err)
	}

	return buf.Bytes(), nil
}

package main

import (
	"context"
	"log"
	"time"

	"github.com/snowmerak/pgolib/profile"
	"github.com/snowmerak/pgolib/storage/minio"

	"signal"
	"os"
)

func main() {
	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
	defer cancel()

	strg, err := minio.NewClient(ctx, "sample", 10, "profile", &minio.Config{
		Endpoint: "localhost:9000",
        Bucket:          "profile",
		AccessKeyID:     "minio",
		SecretAccessKey: "minio123",
	})
	if err != nil {
		panic(err)
	}

	prof := profile.New(strg, 30*time.Minute, 5*time.Minute) // 30 minutes for delay, 5 minutes for collect interval

	errCh, err := prof.Run(ctx)
	if err != nil {
		panic(err)
	}

	done := ctx.Done()
loop:
	for {
		select {
		case err := <-errCh:
			log.Printf("error: %v", err)
		case <-done:
			break loop
		}
	}
	
	log.Println("done")
}

package main

import (
	"context"
	"os"
	"os/signal"
	"time"

	"github.com/snowmerak/pgolib/profile"
	"github.com/snowmerak/pgolib/storage/minio"
)

func main() {
	const (
		appName = "sample"
	)

	var (
		endedAt   = time.Now()
		startedAt = endedAt.Add(-24 * time.Hour)
	)

	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
	defer cancel()

	strg, err := minio.New(ctx, appName, 32, "profile", &minio.Config{
		Endpoint:        "localhost:9000",
		Bucket:          "profile",
		AccessKeyID:     "minio",
		SecretAccessKey: "minio123",
	})
	if err != nil {
		panic(err)
	}

	profiler := profile.NewProfiler(strg, 0, 0)
	data, err := profiler.GetProfile(ctx, startedAt, endedAt)
	if err != nil {
		panic(err)
	}

	f, err := os.Create("profile.pprof")
	if err != nil {
		panic(err)
	}
	defer f.Close()
	defer f.Sync()

	if _, err := f.Write(data); err != nil {
		panic(err)
	}
}

FROM golang:1.23 AS builder
LABEL authors="<your-name>"

ARG PGO=off

WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download

COPY . .

# Build the Go app
RUN CGO_ENABLED=0 go build -pgo=$PGO -o ./build/app ./cmd/app/.

FROM alpine:3.20

WORKDIR /app

COPY --from=builder /app/build/app .

CMD ["./app"]