Deploy a gRPC service in Go

syntax = "proto3";

package acme.catalog.v1;

option go_package = "github.com/acme/catalog/catalogpb";

service CatalogService {
  rpc GetProduct(GetProductRequest) returns (Product);
}

message GetProductRequest {
  int32 id = 1;
}

message Product {
  int32 id = 1;
  string name = 2;
  double price = 3;
}

package main

import (
	"context"
	"log"
	"net"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/health"
	healthpb "google.golang.org/grpc/health/grpc_health_v1"
	"google.golang.org/grpc/reflection"
	"google.golang.org/grpc/status"

	"github.com/acme/catalog/catalogpb"
)

var products = map[int32]*catalogpb.Product{
	1: {Id: 1, Name: "Espresso beans", Price: 14.5},
	2: {Id: 2, Name: "Pour-over kettle", Price: 39},
}

type catalogServer struct {
	catalogpb.UnimplementedCatalogServiceServer
}

func (catalogServer) GetProduct(_ context.Context, req *catalogpb.GetProductRequest) (*catalogpb.Product, error) {
	if p, ok := products[req.GetId()]; ok {
		return p, nil
	}
	return nil, status.Errorf(codes.NotFound, "product %d not found", req.GetId())
}

func main() {
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	lis, err := net.Listen("tcp", ":"+port)
	if err != nil {
		log.Fatal(err)
	}

	srv := grpc.NewServer()
	catalogpb.RegisterCatalogServiceServer(srv, catalogServer{})
	healthSrv := health.NewServer()
	healthpb.RegisterHealthServer(srv, healthSrv)
	reflection.Register(srv)

	// Sevalla's readiness probe sends HTTP/1.1 GET requests, which a gRPC port can't answer,
	// so a second port reports the gRPC health status over HTTP.
	go func() {
		probe := &http.Server{
			Addr:              ":8081",
			ReadHeaderTimeout: 5 * time.Second,
			Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				res, err := healthSrv.Check(r.Context(), &healthpb.HealthCheckRequest{})
				if err != nil || res.GetStatus() != healthpb.HealthCheckResponse_SERVING {
					http.Error(w, "not serving", http.StatusServiceUnavailable)
					return
				}
				w.Write([]byte("ok"))
			}),
		}
		log.Fatal(probe.ListenAndServe())
	}()

	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	go func() {
		log.Printf("Listening on port %s", port)
		if err := srv.Serve(lis); err != nil {
			log.Fatal(err)
		}
	}()

	<-ctx.Done()
	log.Print("Shutting down")
	healthSrv.Shutdown()
	stopped := make(chan struct{})
	go func() {
		srv.GracefulStop()
		close(stopped)
	}()
	select {
	case <-stopped:
	case <-time.After(20 * time.Second):
		srv.Stop()
	}
	log.Print("Server stopped")
}

package main

import (
	"context"
	"encoding/json"
	"errors"
	"log"
	"net/http"
	"os"
	"os/signal"
	"strconv"
	"syscall"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/credentials/insecure"
	"google.golang.org/grpc/status"

	"github.com/acme/catalog/catalogpb"
)

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

func main() {
	// CATALOG_ADDR is the catalog's internal hostname and port, such as
	// catalog-x7k2m-web.catalog-x7k2m.svc.cluster.local:8080
	conn, err := grpc.NewClient(os.Getenv("CATALOG_ADDR"), grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	catalog := catalogpb.NewCatalogServiceClient(conn)

	mux := http.NewServeMux()
	mux.HandleFunc("GET /api/products/{id}", func(w http.ResponseWriter, r *http.Request) {
		id, _ := strconv.Atoi(r.PathValue("id"))
		ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
		defer cancel()
		p, err := catalog.GetProduct(ctx, &catalogpb.GetProductRequest{Id: int32(id)})
		switch {
		case status.Code(err) == codes.NotFound:
			writeJSON(w, http.StatusNotFound, map[string]string{"error": status.Convert(err).Message()})
		case err != nil:
			log.Printf("catalog: %v", err)
			writeJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "catalog unavailable"})
		default:
			writeJSON(w, http.StatusOK, map[string]any{"id": p.GetId(), "name": p.GetName(), "price": p.GetPrice()})
		}
	})

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	srv := &http.Server{Addr: ":" + port, Handler: mux, ReadHeaderTimeout: 10 * time.Second}

	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	go func() {
		log.Printf("Listening on port %s", port)
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Fatal(err)
		}
	}()

	<-ctx.Done()
	log.Print("Shutting down")
	shutdownCtx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer cancel()
	if err := srv.Shutdown(shutdownCtx); err != nil {
		log.Fatal(err)
	}
	log.Print("Server stopped")
}

	if p := os.Getenv("GRPC_PRIVATE_PORT"); p != "" {
		privateLis, err := net.Listen("tcp", ":"+p)
		if err != nil {
			log.Fatal(err)
		}
		go func() {
			log.Printf("Listening on private port %s", p)
			if err := srv.Serve(privateLis); err != nil {
				log.Fatal(err)
			}
		}()
	}

FROM golang:1.27-trixie AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/ . ./cmd/storefront

FROM alpine:3.24
RUN adduser -D -u 1000 app
COPY --from=build /out/ /usr/local/bin/
USER 1000:1000
EXPOSE 8080
CMD ["catalog"]

.git
.env*
*.log
/catalog
/storefront
Dockerfile
.dockerignore