Golang microservice modular architecture with go workspace

Scalable codebase infrastructure

Golang shines in backend development, concurrent operations and is a perfect suite for building scalable and performant backend applications. Due to the lack of posts revolving around It's microservice architecture with go workspaces which is an incredible tool for sharing modular code through different services, I decided to share my implementation.

Project setup

mkdir docker

touch docker/Dockerfile.authentication

touch docker/Dockerfile.users

mkdir -p services/authentication

mkdir -p services/users

mkdir -p shared/utils

touch docker-compose.yml

Following shell commands will produce the following folder tree structure

Setting up go workspace

At the root of the project, create a go workspace simply by using a simple command go work init this will produce the go.work file

Next, initialize all the different go projects that will be able to hold dependencies, and run codebases.

cd services/authentication && go mod init github.com/LegationPro/ms/services/authentication

cd ../.. && cd services/users && go mod init github.com/LegationPro/ms/services/users

cd ../.. && cd shared && go mod init github.com/LegationPro/ms/shared

After running the following commands, your project should look like this

Next, we will populate the go workspace and tell it what is part of the workspace by running the following command

go work use ./services/authentication ./services/users ./shared

This will populate the go.work file

go 1.23.1

use (
    ./services/authentication
    ./services/users
    ./shared
)

Setting it up with Docker

Let's go over the docker-compose.yml first.

Your docker-compose.yml file should look like this

services:
  authentication:
    build:
      context: .
      dockerfile: docker/Dockerfile.authentication
    volumes:
      - ./services/authentication:/app/authentication
      - ./shared:/app/shared
    ports:
      - "8081:8081"

  users:
    build:
      context: .
      dockerfile: docker/Dockerfile.users
    volumes:
      - ./services/users:/app/users
      - ./shared:/app/shared
    ports:
      - "8082:8082"

We tell docker-compose to use the following services which are authentication and users.

We give is the root context, so we can access the files and folders at the root level.

Supply the dockerfile location.

Define the given volume for the container and at the end expose a port for the container to run on.

Setting up Dockerfiles

Setting up the Dockerfile is pretty simple and straight forward.

We pull the latest golang alpine image, assign a working directory, move some of the code around, adjust it to work with the go workspace structure and simply run it.

docker/Dockerfile.authentication

# Pull golang image
FROM golang:1.23-alpine

# Switch to /app as the working directory
WORKDIR /app

# Copy the authentication codebase over to our container
COPY ./services/authentication /app/authentication/

# Copy the shared codebase and libraries that are shared across our apps inside the container
COPY ./shared /app/shared

# Initialize go workspace inside of our container
RUN go work init

# Assign different codebases to go workspaces
RUN go work use ./authentication ./shared

# Simply run our service with this simple command
CMD ["go", "run", "./authentication"]

Dockerfile.users

# Pull golang image
FROM golang:1.23-alpine

# Switch to /app as the working directory
WORKDIR /app

# Copy the authentication codebase over to our container
COPY ./services/users /app/users/

# Copy the shared codebase and libraries that are shared across our apps inside the container
COPY ./shared /app/shared

# Initialize go workspace inside of our container
RUN go work init

# Assign different codebases to go workspaces
RUN go work use ./users ./shared

# Simply run our service with this simple command
CMD ["go", "run", "./users"]

Writing our service code

services/authentication/main.go

package main

import (
    "fmt"

    "github.com/LegationPro/ms/shared/utils"
)

func main() {
    fmt.Println(utils.SomeAuthFunc())
}

services/users/main.go

package main

import (
    "fmt"

    "github.com/LegationPro/ms/shared/utils"
)

func main() {
    fmt.Println(utils.SomeUserFunc())
}

shared/utils/utils.go

package utils

func SomeAuthFunc() string {
    return "Some auth func"
}

func SomeUserFunc() string {
    return "Some user func"
}

The structure should look like this now

Run the application inside a docker container

docker-compose up --build

To make sure everything works the output should be the following:

That's it, you have a fully functional go workspace modular microservice architecture setup! ??

Source code : https://github.com/LegationPro/go-microservice-modular-docker-setup

Thank you

Thank you for reading my blog post, I hope this helps ❤️!

The above is the detailed content of Golang microservice modular architecture with go workspace. For more information, please follow other related articles on the PHP Chinese website!