Горизонтальное масштабирование за LB с общими сессиями Redis, X-Instance-Id, обязательным Idempotency-Key в PostgreSQL, сценариями failover/persistence и измерением цены масштабирования при фиксированном CPU/RAM бюджете.
172 lines
4.3 KiB
Go
172 lines
4.3 KiB
Go
// Точка входа HTTP API и одноразового мигратора.
|
|
//
|
|
// Режимы:
|
|
//
|
|
// (по умолчанию) — API-реплика: ждёт Postgres/Redis, слушает порт, миграции НЕ применяет
|
|
// (их гоняет отдельный сервис migrate, чтобы реплики не гонялись);
|
|
// -migrate — применить встроенные SQL и выйти с кодом 0/1;
|
|
// -healthcheck — локальный probe /health/ready для Docker HEALTHCHECK.
|
|
//
|
|
// SIGTERM: /health/ready → 503 (LB снимает реплику) и Shutdown до 10 секунд.
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
"time"
|
|
|
|
"mtusi2026lab3/internal/api"
|
|
"mtusi2026lab3/internal/auth"
|
|
"mtusi2026lab3/internal/config"
|
|
"mtusi2026lab3/internal/session"
|
|
"mtusi2026lab3/internal/store"
|
|
)
|
|
|
|
func main() {
|
|
healthcheck := flag.Bool("healthcheck", false, "probe local /health/ready and exit")
|
|
migrateOnly := flag.Bool("migrate", false, "apply SQL migrations and exit")
|
|
flag.Parse()
|
|
if *healthcheck {
|
|
os.Exit(runHealthcheck())
|
|
}
|
|
|
|
cfg, err := config.Load()
|
|
if err != nil {
|
|
log.Fatalf("config: %v", err)
|
|
}
|
|
hasher, err := auth.NewHasher()
|
|
if err != nil {
|
|
log.Fatalf("password hasher: %v", err)
|
|
}
|
|
|
|
rootCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
|
|
defer stop()
|
|
|
|
st, err := waitPostgres(rootCtx, cfg.DatabaseURL, hasher, cfg.MaxConns)
|
|
if err != nil {
|
|
log.Fatalf("postgres: %v", err)
|
|
}
|
|
defer st.Close()
|
|
|
|
if *migrateOnly || cfg.RunMigrations {
|
|
if err := st.Migrate(rootCtx); err != nil {
|
|
log.Fatalf("migrate: %v", err)
|
|
}
|
|
log.Printf("migrations applied")
|
|
if *migrateOnly {
|
|
return
|
|
}
|
|
}
|
|
|
|
sessions, err := waitRedis(rootCtx, cfg.RedisURL, cfg.SessionTTL)
|
|
if err != nil {
|
|
log.Fatalf("redis: %v", err)
|
|
}
|
|
defer sessions.Close()
|
|
|
|
srvAPI := api.New(st, sessions, cfg.InstanceID)
|
|
httpServer := &http.Server{
|
|
Addr: cfg.Addr(),
|
|
Handler: srvAPI.Handler(),
|
|
ReadHeaderTimeout: 5 * time.Second,
|
|
ReadTimeout: 15 * time.Second,
|
|
WriteTimeout: 15 * time.Second,
|
|
IdleTimeout: 60 * time.Second,
|
|
}
|
|
|
|
errCh := make(chan error, 1)
|
|
go func() {
|
|
log.Printf("listening on %s env=%s instance=%s session_ttl=%s db_max_conns=%d",
|
|
cfg.Addr(), cfg.Env, cfg.InstanceID, cfg.SessionTTL, cfg.MaxConns)
|
|
if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
|
errCh <- err
|
|
}
|
|
}()
|
|
|
|
select {
|
|
case err := <-errCh:
|
|
log.Fatalf("listen: %v", err)
|
|
case <-rootCtx.Done():
|
|
}
|
|
log.Printf("shutting down instance=%s", cfg.InstanceID)
|
|
srvAPI.BeginDrain()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
if err := httpServer.Shutdown(ctx); err != nil {
|
|
log.Printf("shutdown error: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
log.Printf("shutdown complete")
|
|
}
|
|
|
|
func waitPostgres(ctx context.Context, dsn string, hasher *auth.Hasher, maxConns int32) (*store.Store, error) {
|
|
deadline := time.Now().Add(45 * time.Second)
|
|
var last error
|
|
for {
|
|
st, err := store.Open(ctx, dsn, hasher, maxConns)
|
|
if err == nil {
|
|
return st, nil
|
|
}
|
|
last = err
|
|
if ctx.Err() != nil || time.Now().After(deadline) {
|
|
return nil, last
|
|
}
|
|
log.Printf("postgres not ready, retrying")
|
|
select {
|
|
case <-ctx.Done():
|
|
return nil, ctx.Err()
|
|
case <-time.After(time.Second):
|
|
}
|
|
}
|
|
}
|
|
|
|
func waitRedis(ctx context.Context, redisURL string, ttl time.Duration) (*session.Store, error) {
|
|
deadline := time.Now().Add(45 * time.Second)
|
|
var last error
|
|
for {
|
|
st, err := session.Open(redisURL, ttl)
|
|
if err == nil {
|
|
return st, nil
|
|
}
|
|
last = err
|
|
if ctx.Err() != nil || time.Now().After(deadline) {
|
|
return nil, last
|
|
}
|
|
log.Printf("redis not ready, retrying")
|
|
select {
|
|
case <-ctx.Done():
|
|
return nil, ctx.Err()
|
|
case <-time.After(time.Second):
|
|
}
|
|
}
|
|
}
|
|
|
|
func runHealthcheck() int {
|
|
cfg, err := config.Load()
|
|
if err != nil {
|
|
return 1
|
|
}
|
|
host := cfg.Host
|
|
if host == "0.0.0.0" || host == "::" {
|
|
host = "127.0.0.1"
|
|
}
|
|
client := &http.Client{Timeout: 2 * time.Second}
|
|
resp, err := client.Get(fmt.Sprintf("http://%s:%d/health/ready", host, cfg.Port))
|
|
if err != nil {
|
|
return 1
|
|
}
|
|
defer resp.Body.Close()
|
|
_, _ = io.Copy(io.Discard, resp.Body)
|
|
if resp.StatusCode != http.StatusOK {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|