Go

# Verify the toolchain (1.22 or newer for this track)
go version

mkdir aurora-api && cd aurora-api
go mod init github.com/you/aurora-api

// cmd/api/main.go
package main

import (
	"log/slog"
	"net/http"
	"os"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("ok"))
	})

	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
	logger.Info("listening", "addr", ":8080")
	if err := http.ListenAndServe(":8080", mux); err != nil {
		logger.Error("server failed", "err", err)
		os.Exit(1)
	}
}

go run ./cmd/api
# in another terminal:
curl -i localhost:8080/healthz

mux.HandleFunc("GET /products/{id}", func(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	w.Header().Set("Content-Type", "application/json")
	_, _ = w.Write([]byte(`{"id":"` + id + `"}`))
})

type Product struct {
	ID        string `json:"id"`
	Name      string `json:"name"`
	UnitPrice int64  `json:"unit_price"` // store money as integer cents
}

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

// cmd/api/main_test.go
func TestHealthz(t *testing.T) {
	cases := []struct {
		name   string
		method string
		path   string
		want   int
	}{
		{"ok", "GET", "/healthz", 200},
		{"wrong method", "POST", "/healthz", 405},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			req := httptest.NewRequest(tc.method, tc.path, nil)
			rec := httptest.NewRecorder()
			newRouter().ServeHTTP(rec, req)
			if rec.Code != tc.want {
				t.Fatalf("got %d, want %d", rec.Code, tc.want)
			}
		})
	}
}

go test ./... -run TestHealthz -v

var ErrNotFound = errors.New("not found")

func (s *Store) Product(ctx context.Context, id string) (Product, error) {
	p, ok := s.byID[id]
	if !ok {
		return Product{}, fmt.Errorf("product %q: %w", id, ErrNotFound)
	}
	return p, nil
}

// in the handler:
if errors.Is(err, ErrNotFound) {
	writeJSON(w, http.StatusNotFound, map[string]string{"error": "not found"})
	return
}

import "golang.org/x/sync/errgroup"

func enrich(ctx context.Context, ids []string) ([]Product, error) {
	g, ctx := errgroup.WithContext(ctx)
	g.SetLimit(8) // cap concurrency
	out := make([]Product, len(ids))
	for i, id := range ids {
		i, id := i, id
		g.Go(func() error {
			p, err := fetch(ctx, id)
			if err != nil {
				return err
			}
			out[i] = p
			return nil
		})
	}
	return out, g.Wait()
}

go get golang.org/x/sync/errgroup
go test ./... -race   # the race detector catches data races

go get github.com/jackc/pgx/v5

import "github.com/jackc/pgx/v5/pgxpool"

pool, err := pgxpool.New(ctx, os.Getenv("DATABASE_URL"))
if err != nil { return err }
defer pool.Close()

var price int64
err = pool.QueryRow(ctx,
	`SELECT unit_price FROM products WHERE id = $1`, id,
).Scan(&price)

func run() error {
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	srv := &http.Server{Addr: ":8080", Handler: newRouter()}
	go func() {
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			slog.Error("listen", "err", err)
		}
	}()

	<-ctx.Done() // blocks until a signal
	shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	return srv.Shutdown(shutdownCtx)
}

FROM golang:1.22 AS build
WORKDIR /src
COPY go.* ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /app ./cmd/api

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

docker build -t aurora-api .
docker run -p 8080:8080 -e DATABASE_URL=... aurora-api

func BenchmarkEncode(b *testing.B) {
	p := Product{ID: "p1", Name: "Widget", UnitPrice: 1999}
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_ = json.NewEncoder(io.Discard).Encode(p)
	}
}

go test -bench=. -benchmem ./...
go tool pprof -http=:9000 cpu.out   # flame graph in the browser