how to make container for multiple servers in one code base to deploy golang app with docker?

I have a repo that has multiple servers gonna running. the structure like this

// Golang Apps
- account = port 4001 
- event = port 4002
- place = port 4003

// Node js
- gateway = port 4000

I usually run in local using script like this

// script.sh here:
#!/bin/bash

EnvAPP="${ENV_APP:-dev}"

function cleanup {
    kill "$ACCOUNTS_PID"
    kill "$EVENTS_PID"
    kill "$PLACES_PID"
}
trap cleanup EXIT

go build -tags $EnvAPP -o ./tmp/srv-accounts ./cmd/server/accounts
go build -tags $EnvAPP -o ./tmp/srv-events ./cmd/server/events
go build -tags $EnvAPP -o ./tmp/srv-places ./cmd/server/places

./tmp/srv-accounts &
ACCOUNTS_PID=$!

./tmp/srv-events &
EVENTS_PID=$!

./tmp/srv-places &
PLACES_PID=$!

sleep 1

node ./cmd/gateway/index.js

is that possible I create one Dockerfile for this case into Production? should I run the script.sh in the Dockerfile for this case? how about the image should I use in Dockerfile? I have no idea for this case using docker because the in one code base for multiple servers running , and the problem also port of servers running

maybe one of you ever has this case? it would be great to know how to solve this problem

I am using GraphQL Federation ( Go ) for this case, so I have multiple services and Gateway ( NodeJS )

I want to deploy this into Production for this question

You need four separate Dockerfiles for this, to launch four separate containers with four different programs. The Go component Dockerfiles can be fairly straightforward:

# Dockerfile.accounts
FROM golang:1.16 AS build
WORKDIR /app
COPY . .
ARG ENV_APP=dev
RUN go build -tags "$ENV_APP" -o /accounts ./cmd/server/accounts

FROM ubuntu:20.04
COPY --from=build /accounts /usr/local/bin
CMD accounts

(If the three images are really identical aside from the specific command directory being built, you could pass that in as an ARG as well. I'm assuming the ./cmd/server/* packages require packages elsewhere in your source directory like a ./pkg/support or whatever, which would require the Dockerfiles to be at the top level.)

Since your script is just running the four programs, I'd generally recommend using Docker Compose as a way to launch the four containers together. "Launch some containers with known options" is the only thing Compose does, but it would do everything your script does.

# docker-compose.yml
version: '3.8'
services:
  accounts:
    build:
      context: .
      dockerfile: Dockerfile.accounts
  events:
    build:
      context: .
      dockerfile: Dockerfile.events
  places:
    build:
      context: .
      dockerfile: Dockerfile.places
  gateway:
    build:
      context: .
      dockerfile: Dockerfile.gateway
      # (Since a Node app can't reuse Go code, this could also
      # reasonably be `build: cmd/gateway` using a
      # `cmd/gateway/Dockerfile`)
    ports:
      - 3000:3000

Just running docker-compose up will start all four containers in the foreground; once it's up, pressing <kbd>Ctrl</kbd>+<kbd>C</kbd> will stop them all. You can configure the gateway to use the other container names accounts, events, places as host names; http://accounts/graphql for example.

You could also adapt your launcher script as-is. Run docker build instead of go build to build images, docker run to start a container (probably with fixed --names), docker stop && docker rm to stop them. You should docker network create a network and docker run --net all of the containers on them so they can communicate in the same way as the Compose setup.