How to Deploy a Gin App to Google Cloud Run

// notify/notify.go
package notify

import (
	"context"
	"net/http"
	"time"

	"encore.dev/pubsub"
	"encore.dev/rlog"
	"encore.dev/storage/cache"
	"encore.dev/storage/sqldb"
	"github.com/gin-gonic/gin"
)

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

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

type rateKey struct {
	UserID string
	Hour   string // e.g. 2026-11-12T09
}

// Sends per user per clock hour, gone an hour after the last increment.
var sendsPerHour = cache.NewIntKeyspace[rateKey](cluster, cache.KeyspaceConfig{
	KeyPattern:    "rate/:UserID/:Hour",
	DefaultExpiry: cache.ExpireIn(time.Hour),
})

type Notification struct {
	ID     string `json:"id"` // set by the caller, reused on retries
	UserID string `json:"user_id"`
	Title  string `json:"title"`
	Body   string `json:"body"`
}

// A Pub/Sub topic on GCP; delivery is retried until the handler succeeds.
var Notifications = pubsub.NewTopic[*Notification]("notifications", pubsub.TopicConfig{
	DeliveryGuarantee: pubsub.AtLeastOnce,
})

var _ = pubsub.NewSubscription(Notifications, "send-push",
	pubsub.SubscriptionConfig[*Notification]{Handler: sendPush},
)

const maxPerHour = 5

//encore:service
type Service struct {
	router *gin.Engine
}

func initService() (*Service, error) {
	r := gin.New()
	r.Use(gin.Recovery())
	r.GET("/healthz", func(c *gin.Context) { c.Status(http.StatusOK) })
	r.POST("/notify", enqueue)
	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)
}

func enqueue(c *gin.Context) {
	var n Notification
	if err := c.ShouldBindJSON(&n); err != nil || n.ID == "" || n.UserID == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "id and user_id are required"})
		return
	}
	ctx := c.Request.Context()

	key := rateKey{UserID: n.UserID, Hour: time.Now().UTC().Format("2006-01-02T15")}
	count, err := sendsPerHour.Increment(ctx, key, 1)
	if err != nil {
		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "try again"})
		return
	}
	if count > maxPerHour {
		c.JSON(http.StatusTooManyRequests, gin.H{"error": "hourly limit reached"})
		return
	}

	if _, err := Notifications.Publish(ctx, &n); err != nil {
		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "try again"})
		return
	}
	c.JSON(http.StatusAccepted, gin.H{"id": n.ID})
}

// sendPush records the ID as pending before calling the provider, then
// marks it sent after a successful deliver. A redelivered message whose
// row is already sent is a no-op. A row still pending is retried, so a
// crash between the insert and the provider call cannot drop the send,
// and a cache eviction cannot make it go out twice.
func sendPush(ctx context.Context, n *Notification) error {
	res, err := db.Exec(ctx, `
		INSERT INTO push_deliveries (id, status) VALUES ($1, 'pending')
		ON CONFLICT (id) DO NOTHING
	`, n.ID)
	if err != nil {
		return err
	}
	if res.RowsAffected() == 0 {
		var status string
		if err := db.QueryRow(ctx, `SELECT status FROM push_deliveries WHERE id = $1`, n.ID).Scan(&status); err != nil {
			return err
		}
		if status == "sent" {
			return nil
		}
	}
	if err := deliver(ctx, n); err != nil {
		return err
	}
	_, err = db.Exec(ctx, `
		UPDATE push_deliveries SET status = 'sent' WHERE id = $1 AND status = 'pending'
	`, n.ID)
	return err
}

func deliver(ctx context.Context, n *Notification) error {
	// Call your push provider (FCM, APNs) with Idempotency-Key set to n.ID,
	// so a retry after a crash between a successful send and the status
	// update does not deliver the notification twice.
	rlog.Info("push sent", "id", n.ID, "user", n.UserID)
	return nil
}

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

	// 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("notifications")
	defer pub.Stop()

	r := gin.New()
	r.Use(gin.Recovery())
	registerRoutes(r, rdb, pub)

	// Pub/Sub push subscription target. A 2xx acks the message, anything else retries.
	r.POST("/pubsub/push", func(c *gin.Context) {
		var env struct {
			Message struct {
				Data []byte `json:"data"` // base64 in JSON, decoded by encoding/json
			} `json:"message"`
		}
		var n Notification
		if err := c.ShouldBindJSON(&env); err != nil || json.Unmarshal(env.Message.Data, &n) != nil {
			c.Status(http.StatusNoContent) // malformed, do not retry
			return
		}
		if err := sendOnce(c.Request.Context(), rdb, &n); err != nil {
			c.Status(http.StatusInternalServerError)
			return
		}
		c.Status(http.StatusNoContent)
	})
	log.Fatal(r.Run(":" + os.Getenv("PORT")))
}

FROM golang:1.25 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"]