Microsserviços em Go: arquitetura e prática do A ao Z

Treinador Online de Python para Iniciantes

Aprenda Python facilmente sem sobrecarga teórica. Resolva tarefas práticas com verificação automática e escreva código diretamente no navegador.

Start Course

Introdução aos Microsserviços em Go

A arquitetura de microsserviços tornou-se o padrão de facto para a construção de sistemas distribuídos modernos. A linguagem Go (Golang), com suas goroutines leves, alta performance e simplicidade de implantação, é ideal para a implementação de microsserviços. Neste artigo, vamos analisar a arquitetura de microsserviços em Go, do conceito à implementação prática com exemplos de código.

Go oferece suporte nativo à concorrência, inicialização rápida e tamanho pequeno dos arquivos binários — tudo isso é crucial para microsserviços. Veremos como projetar um serviço, implementar uma REST API, adicionar middleware e preparar a aplicação para conteinerização.

Arquitetura de Microsserviço em Go

1. Estrutura do Projeto

A organização correta do código é a base de um microsserviço sustentável. Estrutura recomendada:

myservice/├── cmd/│   └── server/│       └── main.go          # Ponto de entrada├── internal/│   ├── handler/             # Manipuladores HTTP│   ├── service/             # Lógica de negócios│   ├── repository/          # Operações com dados│   └── middleware/          # Middleware├── pkg/│   └── models/              # Modelos de dados comuns├── config/│   └── config.go            # Configuração├── go.mod└── Dockerfile

Essa estrutura segue os princípios da Clean Architecture: handler → service → repository. Isso permite testar cada camada de forma independente.

2. Configuração e Inicialização

Vamos começar com um servidor HTTP simples usando a biblioteca padrão net/http:

// cmd/server/main.gopackage main

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

func main() {    port := os.Getenv("PORT")    if port == "" {        port = "8080"    }

    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {        w.WriteHeader(http.StatusOK)        fmt.Fprintf(w, `{"status": "ok"}`)    })

    log.Printf("Server starting on :%s", port)    log.Fatal(http.ListenAndServe(":"+port, nil))}

Este é um microsserviço mínimo. Para produção, use um roteador com suporte a middleware, como gorilla/mux ou chi.

Implementação Prática de um Microsserviço

3. REST API com gorilla/mux

Vamos instalar o gorilla/mux e implementar um CRUD para a entidade "Usuário":

// go.modmodule github.com/seuusuario/userservice

go 1.21

require github.com/gorilla/mux v1.8.1

// internal/handler/user.gopackage handler

import (    "encoding/json"    "net/http"    "github.com/gorilla/mux")

type User struct {    ID   string `json:"id"`    Name string `json:"name"`    Age  int    `json:"age"`}

var users = []User{    {ID: "1", Name: "Alice", Age: 30},}

func GetUsers(w http.ResponseWriter, r *http.Request) {    w.Header().Set("Content-Type", "application/json")    json.NewEncoder(w).Encode(users)}

func CreateUser(w http.ResponseWriter, r *http.Request) {    var newUser User    if err := json.NewDecoder(r.Body).Decode(&newUser); err != nil {        http.Error(w, err.Error(), http.StatusBadRequest)        return    }    users = append(users, newUser)    w.WriteHeader(http.StatusCreated)    json.NewEncoder(w).Encode(newUser)}

// cmd/server/main.go (continuação)package main

import (    "log"    "net/http"    "github.com/gorilla/mux"    "seuprojeto/internal/handler")

func main() {    r := mux.NewRouter()    r.HandleFunc("/users", handler.GetUsers).Methods("GET")    r.HandleFunc("/users", handler.CreateUser).Methods("POST")

    log.Println("Server started on :8080")    log.Fatal(http.ListenAndServe(":8080", r))}