How to Deploy a chi App to Google Cloud Run

-- waitlist/migrations/1_waitlist.up.sql
CREATE TABLE signups (
    id         BIGSERIAL PRIMARY KEY,
    sku        TEXT NOT NULL,
    email      TEXT NOT NULL,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    UNIQUE (sku, email)
);

// waitlist/waitlist.go
package waitlist

import (
	"context"
	"encoding/json"
	"errors"
	"net/http"
	"strings"
	"time"

	"encore.dev/pubsub"
	"encore.dev/storage/cache"
	"encore.dev/storage/sqldb"
	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
)

var db = sqldb.NewDatabase("waitlist", sqldb.DatabaseConfig{
	Migrations: "./migrations",
})

// Memorystore for Redis on GCP, an in-memory Redis with `encore run`.
var cluster = cache.NewCluster("waitlist", cache.ClusterConfig{
	EvictionPolicy: cache.AllKeysLRU,
})

type rateWindow struct {
	Email string
	Hour  string // e.g. 2026-11-13T10
}

// Joins per email per clock hour. The hour is part of the key so a
// reset of the expiry on Increment cannot extend the window.
var joins = cache.NewIntKeyspace[rateWindow](cluster, cache.KeyspaceConfig{
	KeyPattern:    "joins/:Email/:Hour",
	DefaultExpiry: cache.ExpireIn(2 * time.Hour),
})

// Signup IDs already notified, kept for a day to drop redeliveries.
var notified = cache.NewStringKeyspace[int64](cluster, cache.KeyspaceConfig{
	KeyPattern:    "notified/:key",
	DefaultExpiry: cache.ExpireIn(24 * time.Hour),
})

type Restocked struct {
	SKU   string `json:"sku"`
	Email string `json:"email"`
	ID    int64  `json:"id"`
}

var Restocks = pubsub.NewTopic[*Restocked]("restocks", pubsub.TopicConfig{
	DeliveryGuarantee: pubsub.AtLeastOnce,
})

var _ = pubsub.NewSubscription(Restocks, "send-email", pubsub.SubscriptionConfig[*Restocked]{
	Handler: sendEmail,
	RetryPolicy: &pubsub.RetryPolicy{
		MinBackoff: 10 * time.Second,
		MaxBackoff: 10 * time.Minute,
		MaxRetries: 8,
	},
})

const maxJoinsPerHour = 5

//encore:service
type Service struct {
	router *chi.Mux
}

func initService() (*Service, error) {
	r := chi.NewRouter()
	r.Use(middleware.RequestID)
	r.Use(middleware.Recoverer)
	r.Get("/healthz", func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusOK)
	})
	r.Post("/waitlist", join)
	r.Post("/skus/{sku}/restock", restock)
	return &Service{router: r}, nil
}

//encore:api public raw path=/!fallback
func (s *Service) Fallback(w http.ResponseWriter, req *http.Request) {
	s.router.ServeHTTP(w, req)
}

type joinBody struct {
	SKU   string `json:"sku"`
	Email string `json:"email"`
}

func join(w http.ResponseWriter, r *http.Request) {
	var body joinBody
	if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<16)).Decode(&body); err != nil {
		http.Error(w, "invalid json", http.StatusBadRequest)
		return
	}
	body.SKU = strings.TrimSpace(body.SKU)
	body.Email = strings.ToLower(strings.TrimSpace(body.Email))
	if body.SKU == "" || body.Email == "" || !strings.Contains(body.Email, "@") {
		http.Error(w, "sku and email are required", http.StatusBadRequest)
		return
	}

	window := rateWindow{Email: body.Email, Hour: time.Now().UTC().Format("2006-01-02T15")}
	n, err := joins.Increment(r.Context(), window, 1)
	if err != nil {
		http.Error(w, "rate limiter unavailable", http.StatusInternalServerError)
		return
	}
	if n > maxJoinsPerHour {
		w.Header().Set("Retry-After", "3600")
		http.Error(w, "too many join attempts", http.StatusTooManyRequests)
		return
	}

	var id int64
	err = db.QueryRow(r.Context(), `
		INSERT INTO signups (sku, email) VALUES ($1, $2)
		ON CONFLICT (sku, email) DO NOTHING
		RETURNING id
	`, body.SKU, body.Email).Scan(&id)
	if errors.Is(err, sqldb.ErrNoRows) {
		writeJSON(w, http.StatusOK, map[string]string{"status": "already_joined"})
		return
	} else if err != nil {
		http.Error(w, "database error", http.StatusInternalServerError)
		return
	}
	writeJSON(w, http.StatusCreated, map[string]any{"id": id, "sku": body.SKU})
}

func restock(w http.ResponseWriter, r *http.Request) {
	sku := chi.URLParam(r, "sku")
	if sku == "" {
		http.Error(w, "sku is required", http.StatusBadRequest)
		return
	}
	rows, err := db.Query(r.Context(), `SELECT id, email FROM signups WHERE sku = $1`, sku)
	if err != nil {
		http.Error(w, "database error", http.StatusInternalServerError)
		return
	}
	defer rows.Close()

	var published int
	for rows.Next() {
		var ev Restocked
		ev.SKU = sku
		if err := rows.Scan(&ev.ID, &ev.Email); err != nil {
			http.Error(w, "database error", http.StatusInternalServerError)
			return
		}
		if _, err := Restocks.Publish(r.Context(), &ev); err != nil {
			http.Error(w, "publish error", http.StatusInternalServerError)
			return
		}
		published++
	}
	if err := rows.Err(); err != nil {
		http.Error(w, "database error", http.StatusInternalServerError)
		return
	}
	writeJSON(w, http.StatusAccepted, map[string]int{"published": published})
}

func sendEmail(ctx context.Context, ev *Restocked) error {
	err := notified.SetIfNotExists(ctx, ev.ID, "sending")
	if errors.Is(err, cache.KeyExists) {
		return nil
	}
	if err != nil {
		return err
	}
	// Send the restock email. Return an error to retry until MaxRetries.
	return nil
}

func writeJSON(w http.ResponseWriter, status int, v any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(v)
}

func main() {
	ctx := context.Background()

	// Cloud Run sets PORT. The Cloud SQL Auth Proxy exposes the instance
	// at /cloudsql/PROJECT:REGION:INSTANCE when --add-cloudsql-instances is set.
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	db, err := sql.Open("pgx", os.Getenv("DATABASE_URL"))
	if err != nil {
		log.Fatal(err)
	}

	// Memorystore has a private IP only; the service reaches it through Direct VPC egress.
	rdb := redis.NewClient(&redis.Options{Addr: os.Getenv("REDISHOST") + ":6379"})

	ps, err := pubsub.NewClient(ctx, pubsub.DetectProjectID)
	if err != nil {
		log.Fatal(err)
	}
	pub := ps.Publisher("restocks")
	defer pub.Stop()

	r := chi.NewRouter()
	r.Use(middleware.RequestID)
	r.Use(middleware.Recoverer)
	registerRoutes(r, db, rdb, pub)

	log.Fatal(http.ListenAndServe(":"+port, r))
}

FROM golang:1.26 AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o /out/api .

FROM gcr.io/distroless/static-debian12:nonroot
COPY --from=build /out/api /api
USER nonroot:nonroot
ENTRYPOINT ["/api"]