- Service discovery
- Auto Authentication

FROM golang:1.15-alpine as builder

WORKDIR /workspace

# Retrieve application dependencies.
# This allows the container build to reuse cached dependencies.
# Expecting to copy go.mod and if present go.sum.
COPY go.* ./
RUN go mod download

# Copy local code to the container image.
COPY . ./

ARG build_target=client

# Build the binary.
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -v -o /app ./$build_target/


# add runsd to the image
ADD https://github.com/ahmetb/runsd/releases/latest/download/runsd /runsd

# gives runsd the correct permissions
RUN chmod +x /runsd


# bare bones distroless image
FROM gcr.io/distroless/base
COPY --from=builder /app /app

# copy runsd to our final image
COPY --from=builder /runsd /runsd

# the most important part is adding runsd before we start our app
ENTRYPOINT ["/runsd", "--", "/app"]

package definitions

// TacoService contains all knowledge around consumption of tacos
type TacoService interface {

    // EatTaco handles keeping track of eating tacos
    EatTaco(request EatTacoRequest) EatTacoResponse
}

// EatTacoRequest is the request for TacoService.EatTaco.
type EatTacoRequest struct {
    // Name is your name
    Name string
    // All of the Tacos you have consumed 🌮
    Tacos []string
}

// EatTacoResponse is the response for TacoService.EatTaco.
type EatTacoResponse struct {
    // Your current taco consumption status
    TacoConsumptionStatus string
}

package main

import (
    "context"
    "errors"
    "fmt"
    "github.com/amammay/otorun/generated/server"
    "github.com/pacedotdev/oto/otohttp"
    "log"
    "net/http"
    "os"
    "time"
)

func main() {

    if err := run(); err != nil {
        fmt.Fprintf(os.Stderr, "%v\n", err)
        os.Exit(1)
    }

}

func run() error {

    // creates new oto base http server
    oto := otohttp.NewServer()

    // register our taco service to the oto server
    server.RegisterTacoService(oto, &tacoService{})

    mux := http.NewServeMux()

    // map the path prefix /oto/ to the oto server and our custom middleware
    mux.Handle("/oto/", userAgentMiddleware(oto))

    // cloud run sets a port env variable that we should respect
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    // create our http server and bind our handle to our mux
    httpServer := &http.Server{
        Handler:      mux,
        Addr:         ":" + port,
        ReadTimeout:  30 * time.Second,
        WriteTimeout: 30 * time.Second,
    }
    log.Printf("Starting server on %s", httpServer.Addr)

    return httpServer.ListenAndServe()

}

// userAgentMiddleware logs the user agent middleware for all requests that come into oto
func userAgentMiddleware(h http.Handler) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {

        if agent := r.UserAgent(); agent != "" {
            log.Printf("info: request from %s", agent)
        }

        // send the request into oto
        h.ServeHTTP(w, r)
    }

}

// tacoService implementation
type tacoService struct {
    // TODO add database
}

// EatTaco will tell you how many tacos you have consumed
func (t *tacoService) EatTaco(ctx context.Context, request server.EatTacoRequest) (*server.EatTacoResponse, error) {
    if request.Name == "" {
        return nil, errors.New("EatTacoRequest.Name is required")
    }
    if len(request.Tacos) <= 0 {
        return nil, errors.New("EatTacoRequest.Tacos is required")
    }

    return &server.EatTacoResponse{TacoConsumptionStatus: fmt.Sprintf("%s has consumed %d tacos", request.Name, len(request.Tacos))}, nil
}

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"

    "cloud.google.com/go/compute/metadata"
    "github.com/amammay/otorun/generated/client"
)

func main() {

    // if we are running on cloud run we will leverage runsd for service discovery
    tacoHost := "http://tacoserver/oto/"
    if !metadata.OnGCE() {
        tacoHost = "http://localhost:8080/oto/"
    }

    // create a new client from our auto generated client
    c := client.New(tacoHost)
    c.Debug = func(s string) {
        fmt.Println(s)
    }
    // create our taco service
    tacoService := client.NewTacoService(c)

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

        // consume some tacos
        tacoResponse, err := tacoService.EatTaco(context.Background(), client.EatTacoRequest{
            Name:  "Sammy Sosa",
            Tacos: []string{"Chicken", "Chorizo"},
        })
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        fmt.Fprint(w, tacoResponse.TacoConsumptionStatus)
    })

    // cloud run sets a port env variable that we should respect
    port := os.Getenv("PORT")
    if port == "" {
        port = "8081"
    }

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

}

curl -H \
"Authorization: Bearer $(gcloud auth print-identity-token)" \
$(gcloud run services describe tacoclient --format 'value(status.url)')