Dockerfile for Go project of two runnables with shared packages

I am have a project that includes a client-server with multiple shared files. I am trying to create docker images for the client and server, and struggling with writing the dockerfile.
I have looked at online sources which mostly include very simple projects or projects that are too big and weren't helpful on this matter.

My project structure is following the standard project layout:

Project
    -api
        -api.go
    -cmd
        -client
            -client.go
        -server
            -server.go
    -configs
        -configuration.yaml
    -internal
        -client_int
            -client_logic.go
        -server_int
            -server_logic.go
        -shared_int
            -shared_logic.go
    -Dockerfile
    -go.mod

Would anyone please be able to advise/comment on the project structure or have a similar dockerfile as example?

Thanks.

*I looked into many tutorials that come up on google or with simple github keywords.

With this (very normal) project layout, there are two important details:

1. When you build the image, the context directory (the Compose build: { context: }, or the docker build directory argument) must be the top-level Project directory.
2. Wherever the Dockerfile physically is, the left-hand side of any COPY instructions must be relative to the Project directory (the context directory from the previous point).

There are some choices on how to build Docker images out of this. You could build one image with both the client and server, or a separate image for each, and you could put the Dockerfile(s) at the top directory or in the relevant cmd subdirectory; for a project like this I don't think there's a standard way to do it.

To pick an approach (by no means "the best" approach, but one that will work) let's say we create separate images for each part; but, since so much code is shared, you basically need to copy the whole source tree in to do the image build.

# cmd/server/Dockerfile
# Build-time stage:
FROM golang:alpine AS build
WORKDIR /build

# First install library dependencies
# (These are expensive to download and change rarely;
# doing this once up front saves time on rebuilds)
COPY go.mod go.sum .
RUN go mod install

# Copy the whole application tree in
COPY . .

# Build the specific component we want to run
RUN go build -o server ./cmd/server

# Final runtime image:
FROM alpine
# Get the built binary
COPY --from=build /build/server /usr/bin
# And set it as the main container command
CMD ["server"]

And maybe you're running this via Docker Compose:

version: '3.8'
services:
  server:
    build:
      context: .
      dockerfile: cmd/server/Dockerfile
    ports:
      - 8000:8000
  client:
    build:
      context: .
      dockerfile: cmd/client/Dockerfile
    environment:
      SERVER_URL: 'http://server:8000'

Note that both images specify the project root directory as the build context:, but then specify a different dockerfile: for each.