Infraestrutura de base de código escalável

Golang brilha no desenvolvimento de back-end, operações simultâneas e é um conjunto perfeito para construir aplicativos de back-end escalonáveis ​​e de alto desempenho. Devido à falta de postagens girando em torno de sua arquitetura de microsserviços com espaços de trabalho go, que é uma ferramenta incrível para compartilhar código modular por meio de diferentes serviços, decidi compartilhar minha implementação.

Configuração do projeto

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

Os seguintes comandos do shell produzirão a seguinte estrutura de árvore de pastas

Configurando o espaço de trabalho Go

Na raiz do projeto, crie um espaço de trabalho go simplesmente usando um comando simples go work init isso produzirá o arquivo go.work

Em seguida, inicialize todos os diferentes projetos go que serão capazes de manter dependências e executar bases de código.

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

Depois de executar os comandos a seguir, seu projeto deverá ficar assim

Em seguida, preencheremos o espaço de trabalho go e informaremos o que faz parte do espaço de trabalho executando o seguinte comando

vá trabalhar, use ./services/authentication ./services/users ./shared

Isso preencherá o arquivo go.work

go 1.23.1

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

Configurando com Docker

Vamos examinar docker-compose.yml primeiro.

Seu arquivo docker-compose.yml deve ficar assim

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"

Dizemos ao docker-compose para usar os seguintes serviços que são autenticação e usuários.

Damos o contexto raiz, para que possamos acessar os arquivos e pastas no nível raiz.

Forneça a localização do dockerfile.

Defina o volume fornecido para o contêiner e no final exponha uma porta para o contêiner rodar.

Configurando Dockerfiles

Configurar o Dockerfile é bastante simples e direto.

Extraímos a imagem golang alpine mais recente, atribuímos um diretório de trabalho, movemos parte do código, ajustamos para funcionar com a estrutura do espaço de trabalho go e simplesmente executamos.

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"]

Escrevendo nosso código de serviço

serviços/autenticação/main.go

package main

import (
    "fmt"

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

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

serviços/usuários/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"
}

A estrutura deve ficar assim agora

Execute o aplicativo dentro de um contêiner docker

docker-compose up --build

Para garantir que tudo funcione, a saída deve ser a seguinte:

É isso, você tem uma configuração de arquitetura modular de microsserviços go workspace totalmente funcional! ??

Código fonte: https://github.com/LegationPro/go-microservice-modular-docker-setup

Obrigado

Obrigado por ler a postagem do meu blog, espero que isso ajude ❤️!