Como Criar um Microsserviço de Validação de CPF em Go

// Estrutura de diretórios
// cpf-service/
// cmd/
// server/
// main.go
// internal/
// handler/
// cpf_handler.go
// service/
// cpf_service.go
// client/
// cpfhub_client.go
// validator/
// cpf_validator.go
// model/
// cpf.go
// go.mod
// go.sum
// Dockerfile

// internal/model/cpf.go
package model

type ConsultaCPFRequest struct {
    CPF string `json:"cpf"`
}

type ConsultaCPFResponse struct {
    Sucesso bool `json:"sucesso"`
    Fonte string `json:"fonte"`
    Dados *DadosCPF `json:"dados,omitempty"`
    Erro string `json:"erro,omitempty"`
}

type DadosCPF struct {
    CPF string `json:"cpf"`
    Nome string `json:"name"`
    NomeUpper string `json:"nameUpper"`
    Genero string `json:"gender"`
    DataNascimento string `json:"birthDate"`
    Dia int `json:"day"`
    Mes int `json:"month"`
    Ano int `json:"year"`
}

type APIResponse struct {
    Success bool `json:"success"`
    Data *DadosCPF `json:"data,omitempty"`
}

// internal/validator/cpf_validator.go
package validator

import (
    "regexp"
    "strconv"
)

var apenasDigitos = regexp.MustCompile(`\D`)

func LimparCPF(cpf string) string {
    return apenasDigitos.ReplaceAllString(cpf, "")
}

func ValidarCPF(cpf string) bool {
    cpfLimpo := LimparCPF(cpf)

    if len(cpfLimpo) != 11 {
    return false
    }

    // Verificar se todos os dígitos são iguais
    todosIguais := true
    for i := 1; i < 11; i++ {
    if cpfLimpo[i] != cpfLimpo[0] {
    todosIguais = false
    break
    }
    }
    if todosIguais {
    return false
    }

    // Validar primeiro dígito verificador
    soma := 0
    for i := 0; i < 9; i++ {
    d, _ := strconv.Atoi(string(cpfLimpo[i]))
    soma += d * (10 - i)
    }
    resto := (soma * 10) % 11
    if resto == 10 {
    resto = 0
    }
    d9, _ := strconv.Atoi(string(cpfLimpo[9]))
    if resto != d9 {
    return false
    }

    // Validar segundo dígito verificador
    soma = 0
    for i := 0; i < 10; i++ {
    d, _ := strconv.Atoi(string(cpfLimpo[i]))
    soma += d * (11 - i)
    }
    resto = (soma * 10) % 11
    if resto == 10 {
    resto = 0
    }
    d10, _ := strconv.Atoi(string(cpfLimpo[10]))
    return resto == d10
}

// internal/client/cpfhub_client.go
package client

import (
    "encoding/json"
    "fmt"
    "net/http"
    "time"

    "cpf-service/internal/model"
)

type CPFHubClient struct {
    httpClient *http.Client
    baseURL string
    apiKey string
}

func NewCPFHubClient(apiKey string) *CPFHubClient {
    return &CPFHubClient{
    httpClient: &http.Client{
    Timeout: 10 * time.Second,
    },
    baseURL: "https://api.cpfhub.io",
    apiKey: apiKey,
    }
}

func (c *CPFHubClient) ConsultarCPF(cpf string) (*model.APIResponse, error) {
    url := fmt.Sprintf("%s/cpf/%s", c.baseURL, cpf)

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
    return nil, fmt.Errorf("erro ao criar requisicao: %w", err)
    }

    req.Header.Set("x-api-key", c.apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := c.httpClient.Do(req)
    if err != nil {
    return nil, fmt.Errorf("erro na requisicao: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
    return nil, fmt.Errorf("API retornou status %d", resp.StatusCode)
    }

    var resultado model.APIResponse
    if err := json.NewDecoder(resp.Body).Decode(&resultado); err != nil {
    return nil, fmt.Errorf("erro ao decodificar resposta: %w", err)
    }

    return &resultado, nil
}

// internal/handler/cpf_handler.go
package handler

import (
    "encoding/json"
    "net/http"

    "cpf-service/internal/client"
    "cpf-service/internal/model"
    "cpf-service/internal/validator"
)

type CPFHandler struct {
    apiClient *client.CPFHubClient
}

func NewCPFHandler(apiClient *client.CPFHubClient) *CPFHandler {
    return &CPFHandler{apiClient: apiClient}
}

func (h *CPFHandler) Consultar(w http.ResponseWriter, r *http.Request) {
    cpf := r.PathValue("cpf")
    cpfLimpo := validator.LimparCPF(cpf)

    w.Header().Set("Content-Type", "application/json")

    if !validator.ValidarCPF(cpfLimpo) {
    w.WriteHeader(http.StatusBadRequest)
    json.NewEncoder(w).Encode(model.ConsultaCPFResponse{
    Sucesso: false,
    Erro: "CPF invalido",
    })
    return
    }

    resultado, err := h.apiClient.ConsultarCPF(cpfLimpo)
    if err != nil {
    w.WriteHeader(http.StatusBadGateway)
    json.NewEncoder(w).Encode(model.ConsultaCPFResponse{
    Sucesso: false,
    Erro: "Erro ao consultar API externa",
    })
    return
    }

    if !resultado.Success {
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(model.ConsultaCPFResponse{
    Sucesso: false,
    Fonte: "api",
    Erro: "CPF nao encontrado",
    })
    return
    }

    json.NewEncoder(w).Encode(model.ConsultaCPFResponse{
    Sucesso: true,
    Fonte: "api",
    Dados: resultado.Data,
    })
}

// cmd/server/main.go
package main

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

    "cpf-service/internal/client"
    "cpf-service/internal/handler"
)

func main() {
    apiKey := os.Getenv("CPFHUB_API_KEY")
    if apiKey == "" {
    log.Fatal("CPFHUB_API_KEY nao definida")
    }

    apiClient := client.NewCPFHubClient(apiKey)
    cpfHandler := handler.NewCPFHandler(apiClient)

    mux := http.NewServeMux()
    mux.HandleFunc("GET /api/cpf/{cpf}", cpfHandler.Consultar)
    mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    fmt.Fprint(w, `{"status":"ok"}`)
    })

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

    log.Printf("Servidor iniciado na porta %s", port)
    log.Fatal(http.ListenAndServe(":"+port, mux))
}

FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o /cpf-service ./cmd/server

FROM alpine:3.19
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /cpf-service .
EXPOSE 8080
CMD ["./cpf-service"]