DEV Community: Vinícius Boscardin

Gerenciando o Pull de Conexões do banco de dados com Golang

Vinícius Boscardin — Wed, 12 Feb 2025 18:14:12 +0000

Quando trabalhamos com bancos de dados em uma aplicação Go, é essencial gerenciar corretamente o pool de conexões para garantir que o sistema seja eficiente e escalável. O gerenciamento adequado do pool de conexões evita problemas de latência, erros de timeout e sobrecarga no banco de dados.

O que é um Pool de Conexões?

Um pool de conexões é uma técnica que permite reutilizar conexões com o banco de dados, evitando o custo de abrir e fechar conexões repetidamente. O Go, através do pacote database/sql, oferece suporte nativo para gerenciamento de conexões, criando um pool de conexões automaticamente.

Como Funciona o Gerenciamento de Conexões no Go

O pacote database/sql provê diversas funções para gerenciar o pool de conexões, controlando o número de conexões ativas e inativas, além do tempo de vida de cada conexão. As principais funções de gerenciamento são:

db.SetMaxOpenConns(n int): Define o número máximo de conexões abertas com o banco de dados. Se esse número for excedido, novas requisições de conexão serão enfileiradas até que uma conexão seja liberada.
db.SetMaxIdleConns(n int): Configura o número máximo de conexões inativas (conexões que estão abertas mas não estão sendo usadas). O valor padrão geralmente é 2.
db.SetConnMaxLifetime(d time.Duration): Define a duração máxima que uma conexão pode permanecer aberta, independentemente de estar ativa ou inativa. Conexões mais antigas que este valor serão descartadas.
db.SetConnMaxIdleTime(d time.Duration): Estabelece o tempo máximo que uma conexão pode ficar ociosa. Conexões que estiverem ociosas por mais tempo do que este limite serão fechadas. Esta função é útil para manter um número reduzido de conexões ociosas, evitando o uso desnecessário de recursos.

Exemplo de Configuração de Pool

Abaixo, um exemplo simples de como configurar o pool de conexões em uma aplicação Go utilizando todas as funções de gerenciamento disponíveis:

package main

import (
    "database/sql"
    "fmt"
    "log"
    "time"

    _ "github.com/lib/pq" // Importa o driver Postgres
)

func main() {
    // Abre a conexão com o banco de dados
    db, err := sql.Open("postgres", "user=usuario dbname=meubanco sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Configura o pool de conexões
    db.SetMaxOpenConns(50)             // Máximo de 50 conexões abertas
    db.SetMaxIdleConns(25)             // Máximo de 25 conexões inativas
    db.SetConnMaxLifetime(10 * time.Minute) // Conexões vivas por no máximo 10 minutos
    db.SetConnMaxIdleTime(5 * time.Minute)  // Conexões inativas por no máximo 5 minutos


}

Estrutura `sql.DBStats`

A função db.Stats() retorna uma estrutura do tipo sql.DBStats, que contém as seguintes informações:

OpenConnections: O número total de conexões abertas atualmente, incluindo tanto as inativas quanto as ativas.
InUse: O número de conexões atualmente em uso, ou seja, conexões que estão sendo ativamente utilizadas pela aplicação.
Idle: O número de conexões inativas (disponíveis para reutilização no pool).
WaitCount: O número de vezes que a aplicação precisou esperar por uma nova conexão porque todas as conexões abertas estavam em uso. Esse número pode indicar que o limite de conexões abertas foi atingido.
WaitDuration: O tempo total que a aplicação passou esperando por uma conexão disponível. Um valor alto pode indicar que o sistema está atingindo o limite de conexões com frequência.
MaxIdleClosed: O número de conexões que foram fechadas automaticamente porque estavam ociosas por muito tempo e ultrapassaram o limite definido em SetConnMaxIdleTime.
MaxLifetimeClosed: O número de conexões que foram fechadas porque atingiram o limite máximo de tempo de vida definido em SetConnMaxLifetime.

Essas métricas são úteis para monitorar a saúde do pool de conexões e o desempenho da aplicação em relação ao banco de dados. Se houver muitos fechamentos de conexão por tempo de inatividade (MaxIdleClosed) ou tempo de vida excedido (MaxLifetimeClosed), isso pode ser um sinal de que a configuração do pool precisa ser ajustada.

Exemplo de Monitoramento do Pool de Conexões

Aqui está um exemplo de como você pode monitorar as estatísticas do pool de conexões em uma aplicação Go:

stats := db.Stats()
fmt.Printf("Conexões abertas: %d\n", stats.OpenConnections)
fmt.Printf("Conexões em uso: %d\n", stats.InUse)
fmt.Printf("Conexões inativas: %d\n", stats.Idle)
fmt.Printf("Vezes esperando por conexões: %d\n", stats.WaitCount)
fmt.Printf("Tempo esperando por conexões: %s\n", stats.WaitDuration)
fmt.Printf("Conexões fechadas por inatividade: %d\n", stats.MaxIdleClosed)
fmt.Printf("Conexões fechadas por tempo de vida: %d\n", stats.MaxLifetimeClosed)

Implementando Observabilidade em Aplicações Go com OpenTelemetry, Prometheus, Loki, Tempo e Grafana

Vinícius Boscardin — Sun, 09 Feb 2025 16:29:41 +0000

Vamos mergulhar no mundo da observabilidade em aplicações Go. Se você já se perguntou como monitorar o que está acontecendo nos bastidores do seu código, está no lugar certo!

A observabilidade é como ter superpoderes para entender o comportamento e a saúde das suas aplicações, especialmente quando estão rodando em produção. Com as ferramentas certas, podemos detectar e resolver problemas antes que eles afetem seus usuários.

Vamos usar uma combinação poderosa de ferramentas: OpenTelemetry, Prometheus, Loki, Tempo e Grafana. Cada uma delas tem um papel especial na coleta, armazenamento e visualização dos dados que importam.

Ferramentas de Observabilidade Utilizadas

OpenTelemetry

Um framework de código aberto que fornece APIs, bibliotecas e agentes para coletar dados de telemetria, como métricas, logs e traces. Ele é a base para instrumentar seu código, permitindo que você colete dados de desempenho e comportamento de suas aplicações.

Prometheus

Uma ferramenta de monitoramento e alerta que coleta e armazena métricas em um banco de dados de séries temporais. Ele é ideal para monitorar a performance de aplicações, oferecendo uma linguagem de consulta poderosa para analisar dados e criar alertas baseados em condições específicas.

Loki

Uma solução de agregação de logs que funciona de forma semelhante ao Prometheus, mas para logs. Ele permite que você colete, armazene e consulte logs de forma eficiente, sem a necessidade de indexação completa, tornando-o uma solução leve e escalável para gerenciamento de logs.

Tempo

Uma ferramenta de rastreamento distribuído que permite visualizar e analisar traces de suas aplicações. Com o Tempo, você pode entender o fluxo de requisições através de diferentes serviços, identificar gargalos e otimizar o desempenho de suas aplicações.

Grafana

Uma plataforma de visualização de dados que se integra com Prometheus, Loki, Tempo e outras fontes de dados. Ele permite criar dashboards interativos e visualizações personalizadas para monitorar métricas, logs e traces em tempo real, facilitando a análise e o diagnóstico de problemas.

Vamos Colocar a Mão na Massa!

Agora que já conhecemos as ferramentas que vamos usar, é hora de colocar a mão na massa e começar a implementar a observabilidade na nossa aplicação Go. Vamos configurar o ambiente, instrumentar nosso código e integrar tudo para que possamos monitorar e analisar o desempenho da nossa aplicação em tempo real.

Pré-requisitos

Antes de começarmos, certifique-se de que você tem o Go e o Docker instalados em sua máquina. Eles são essenciais para configurar o ambiente de desenvolvimento e executar os serviços necessários para implementar a observabilidade.

Guia de Instalação do Go

Guia de Instalação do Docker

Desafio de Implementação

Service1 ( http://localhost:8081/service1 ):
- Função: Service1 recebe uma requisição do cliente. Ele processa a requisição e faz uma chamada para Service2.
- Resposta: Após receber a resposta de Service2, Service1 retorna uma resposta ao cliente com um objeto JSON contendo a palavra concatenada, por exemplo, {"word": "CBA"} .
Service2 ( http://localhost:8081/service2 ):
- Função: Service2 recebe uma requisição de Service1. Ele processa a requisição e faz uma chamada para Service3.
- Resposta: Após receber a resposta de Service3, Service2 retorna uma resposta para Service1 com um objeto JSON contendo a palavra concatenada, por exemplo, {"word": "CB"} .
Service3 ( http://localhost:8081/service3 ):
- Função: Service3 recebe uma requisição de Service2. Ele processa a requisição e retorna uma resposta para Service2.
- Resposta: Service3 retorna um objeto JSON contendo uma palavra, por exemplo, {"word": "C"} .

Fluxo de Requisições

O cliente inicia o fluxo enviando uma requisição para Service1.
Service1 processa a requisição e encaminha para Service2.
Service2 processa a requisição e encaminha para Service3.
Service3 processa a requisição e retorna uma resposta para Service2.
Service2 recebe a resposta de Service3, processa e retorna para Service1.
Service1 recebe a resposta de Service2, processa e retorna para o cliente.

Basicamente, cada serviço gera uma palavra com um número específico de caracteres e a concatena com a resposta recebida do próximo serviço. Isso cria uma cadeia de palavras que é passada de um serviço para o outro, até que a resposta final seja enviada de volta ao cliente.

Arquitetura do Projeto

O projeto foi estruturado utilizando o padrão de arquitetura Ports and Adapters, também conhecido como Arquitetura Hexagonal. Esse padrão promove a separação de preocupações, permitindo que a lógica de negócio seja isolada de detalhes de implementação, como frameworks e bibliotecas externas. Aqui está uma descrição de como a estrutura e a arquitetura do projeto foram montadas:

├── Dockerfile
├── LICENSE
├── cmd
│   ├── cmd
│   │   ├── root.go
│   │   └── serve.go
│   └── main.go
├── config-files
│   ├── loki.yaml
│   ├── otel.yaml
│   ├── prometheus.yaml
│   └── tempo.yaml
├── docker-compose.yaml
├── go.mod
├── go.sum
├── internals
│   ├── domain
│   │   ├── core
│   │   │   └── domain
│   │   │       └── example.go
│   │   └── usecase
│   │       └── example.go
│   └── infra
│       ├── controller
│       │   └── example.go
│       └── repository
│           └── example_http.go
├── pkg
│   ├── adapter
│   │   ├── instrumentation
│   │   │   └── otel.go
│   │   ├── metric
│   │   │   └── metric.go
│   │   └── rest
│   │       └── rest.go
│   └── di
│       └── example.go
└── post.md

Estrutura do Projeto

cmd : Contém o ponto de entrada da aplicação, que é implementado usando o cobra-cli . O arquivo serve.go define o comando para iniciar o serviço HTTP instrumentado com OpenTelemetry.

./cmd/cmd/serve.go

package cmd

import (
    "context"
    "time"

    "github.com/booscaaa/observability-go-example/pkg/adapter/instrumentation"
    "github.com/booscaaa/observability-go-example/pkg/adapter/metric"
    "github.com/booscaaa/observability-go-example/pkg/adapter/rest"
    "github.com/spf13/cobra"
    "go.opentelemetry.io/otel"
)

var serveCmd = &cobra.Command{
    Use:   "serve",
    Short: "Start an OpenTelemetry-instrumented HTTP service",
    Long: `Starts an HTTP service that is instrumented with OpenTelemetry for observability.

This service exposes metrics, traces, and logs that can be collected and analyzed
by OpenTelemetry collectors. The service responds with its name and demonstrates
distributed tracing capabilities when called through the Traefik reverse proxy.

Example usage:
  observability-go-example serve`,
    Run: func(cmd *cobra.Command, args []string) {
        shutdown, err := instrumentation.Initialize(cmd.Context())
        if err != nil {
            panic(err)
        }

        defer func() {
            ctx, cancel := context.WithTimeout(cmd.Context(), time.Second*5)
            defer cancel()
            if err := shutdown(ctx); err != nil {
                panic("failed to shutdown TracerProvider")
            }
        }()

        metric.Initialize(otel.GetMeterProvider().Meter(instrumentation.Name))

        rest.Initialize()
    },
}

func init() {
    rootCmd.AddCommand(serveCmd)
}

config-files : Armazena arquivos de configuração para as ferramentas de observabilidade, como Loki, OpenTelemetry, Prometheus e Tempo. Esses arquivos definem como cada ferramenta deve ser configurada e integrada ao projeto.

./config-files/loki.yaml

auth_enabled: false

server:
  http_listen_port: 3100

ingester:
  lifecycler:
    ring:
      kvstore:
        store: inmemory
      replication_factor: 1
  chunk_idle_period: 5m
  chunk_retain_period: 30s

schema_config:
  configs:
    - from: 2020-10-24
      store: boltdb-shipper
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 24h

storage_config:
  boltdb_shipper:
    active_index_directory: /loki/index
    cache_location: /loki/index_cache
    shared_store: filesystem

limits_config:
  enforce_metric_name: false
  reject_old_samples: true
  reject_old_samples_max_age: 168h

chunk_store_config:
  max_look_back_period: 0s

./config-files/otel.yaml

receivers:
  otlp:
    protocols:
      http:
        endpoint: "0.0.0.0:4318"
      grpc:
        endpoint: "0.0.0.0:4317"

exporters:
  prometheus:
    endpoint: "0.0.0.0:8889"
    resource_to_telemetry_conversion:
      enabled: true

  loki:
    endpoint: "http://loki:3100/loki/api/v1/push"

  otlp:
    endpoint: "tempo:4319"
    tls:
      insecure: true

processors:
  batch:

service:
  telemetry:
    metrics:
      level: detailed


  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp]

    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus]

    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [loki]

./config-files/prometheus.yaml

global:
  scrape_interval: 10s

scrape_configs:
  - job_name: "otel-collector"
    static_configs:
      - targets: ["otel-collector:8889"]
  - job_name: "tempo"
    static_configs:
      - targets: ["tempo:3200"]

./config-files/tempo.yaml

server:
  http_listen_port: 3200

distributor:
  receivers:
    otlp:
      protocols:
        grpc:
          endpoint: "0.0.0.0:4319"
        http:
  forwarders:
    - name: otlp
      backend: otlpgrpc
      otlpgrpc:
        tls:
          insecure: true

storage:
  trace:
    backend: local
    local:
      path: /var/tempo/traces

internals : Contém a lógica de negócio e a infraestrutura da aplicação.

domain : Define as entidades e interfaces principais do domínio da aplicação. Por exemplo, Example representa uma entidade de domínio.
usecase : Implementa os casos de uso da aplicação, que são as operações principais que a aplicação pode realizar.
infra : Contém a implementação dos controladores e repositórios que interagem com o mundo externo.

./internals/domain/core/domain/example.go

package domain

import (
    "context"
    "net/http"
)

type Example struct {
    Word string `json:"word"`
}

type ExampleHttpRepository interface {
    GetExample(context.Context) (*Example, error)
}

type ExampleUseCase interface {
    GetExample(context.Context) (*Example, error)
}

type ExampleController interface {
    GetExample(http.ResponseWriter, *http.Request)
}

func (example *Example) ConcatenateWord(word string) {
    example.Word += word
}

./internals/core/usecase/example.go

package usecase

import (
    "context"
    "os"

    "math/rand"

    "github.com/booscaaa/observability-go-example/internals/domain/core/domain"
    "github.com/booscaaa/observability-go-example/pkg/adapter/instrumentation"
)

type exampleUseCase struct {
    exampleHttpRepository domain.ExampleHttpRepository
}

func (usecase *exampleUseCase) GetExample(ctx context.Context) (*domain.Example, error) {
    ctx, span := instrumentation.Tracer.Start(ctx, "usecase.GetExample")
    defer span.End()

    instrumentation.Logger.InfoContext(ctx, "Processing example use case")

    url := os.Getenv("SERVICE_CALL_URL")

    length := rand.Intn(10) + 1
    letters := make([]rune, length)
    for i := range letters {
        letters[i] = rune('A' + rand.Intn(26))
    }
    word := string(letters)

    if url == "" {
        instrumentation.Logger.InfoContext(ctx, "No service URL configured, returning local letter",
            "word", word,
        )
        return &domain.Example{
            Word: word,
        }, nil
    }

    example, err := usecase.exampleHttpRepository.GetExample(ctx)
    if err != nil {
        instrumentation.Logger.ErrorContext(ctx, "Failed to get example from repository",
            "error", err,
            "url", url,
        )
        span.RecordError(err)
        return nil, err
    }

    example.ConcatenateWord(word)
    instrumentation.Logger.InfoContext(ctx, "Successfully processed example",
        "final_word", example.Word,
    )

    return example, nil
}

func NewExampleHttpRepository(exampleHttpRepository domain.ExampleHttpRepository) domain.ExampleUseCase {
    return &exampleUseCase{
        exampleHttpRepository: exampleHttpRepository,
    }
}

./internals/infra/controller/example.go

package controller

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

    "github.com/booscaaa/observability-go-example/internals/domain/core/domain"
    "github.com/booscaaa/observability-go-example/pkg/adapter/instrumentation"
    "github.com/booscaaa/observability-go-example/pkg/adapter/metric"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/propagation"
)

type exampleController struct {
    exampleUseCase domain.ExampleUseCase
}

func (controller *exampleController) GetExample(response http.ResponseWriter, request *http.Request) {
    ctx := request.Context()
    propagator := otel.GetTextMapPropagator()
    ctx = propagator.Extract(ctx, propagation.HeaderCarrier(request.Header))

    ctx, span := instrumentation.Tracer.Start(ctx, "controller.GetExample")
    defer span.End()

    start := time.Now()
    metric.RequestInFlight.Add(ctx, 1)
    metric.RequestCounter.Add(ctx, 1)
    defer func() {
        metric.RequestInFlight.Add(ctx, -1)
        metric.RequestDuration.Record(ctx, time.Since(start).Seconds())
    }()

    instrumentation.Logger.InfoContext(ctx, "Processing request",
        "method", request.Method,
        "path", request.URL.Path,
    )

    example, err := controller.exampleUseCase.GetExample(ctx)
    if err != nil {
        instrumentation.Logger.ErrorContext(ctx, "Failed to get example",
            "error", err,
            "method", request.Method,
            "path", request.URL.Path,
            "status", http.StatusInternalServerError,
        )
        span.RecordError(err)
        response.WriteHeader(http.StatusInternalServerError)
        response.Write([]byte(err.Error()))
        return
    }

    metric.LetterCounter.Add(ctx, 1)
    metric.WordLengthGauge.Record(ctx, int64(len(example.Word)))

    response.WriteHeader(http.StatusOK)
    err = json.NewEncoder(response).Encode(example)
    if err != nil {
        instrumentation.Logger.ErrorContext(ctx, "Failed to encode response",
            "error", err,
            "method", request.Method,
            "path", request.URL.Path,
            "status", http.StatusInternalServerError,
        )
        span.RecordError(err)
        response.WriteHeader(http.StatusInternalServerError)
        response.Write([]byte(err.Error()))
        return
    }
}

func NewExampleController(exampleUseCase domain.ExampleUseCase) domain.ExampleController {
    return &exampleController{
        exampleUseCase: exampleUseCase,
    }
}

./internals/infra/repository/example_http.go

package repository

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

    "github.com/booscaaa/observability-go-example/internals/domain/core/domain"
    "github.com/booscaaa/observability-go-example/pkg/adapter/instrumentation"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/propagation"
)

type exampleHttpRepository struct{}

func (repository *exampleHttpRepository) GetExample(ctx context.Context) (*domain.Example, error) {
    ctx, span := instrumentation.Tracer.Start(ctx, "repository.GetExample")
    defer span.End()

    time.Sleep(10 * time.Second)

    url := os.Getenv("SERVICE_CALL_URL")
    instrumentation.Logger.InfoContext(ctx, "Making HTTP request", "url", url)

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)

    if err != nil {
        instrumentation.Logger.ErrorContext(ctx, "Failed to create request",
            "error", err,
            "url", url,
        )
        span.RecordError(err)
        return nil, err
    }

    propagator := otel.GetTextMapPropagator()
    propagator.Inject(ctx, propagation.HeaderCarrier(req.Header))

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        instrumentation.Logger.ErrorContext(ctx, "Failed to execute request",
            "error", err,
            "url", url,
        )
        span.RecordError(err)
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        err := fmt.Errorf("unexpected status code: %d", resp.StatusCode)
        instrumentation.Logger.ErrorContext(ctx, "Received non-200 status code",
            "error", err,
            "status_code", resp.StatusCode,
            "url", url,
        )
        span.RecordError(err)
        return nil, err
    }

    var exampleResponse domain.Example
    if err := json.NewDecoder(resp.Body).Decode(&exampleResponse); err != nil {
        instrumentation.Logger.ErrorContext(ctx, "Failed to decode response",
            "error", err,
            "url", url,
        )
        span.RecordError(err)
        return nil, err
    }

    instrumentation.Logger.InfoContext(ctx, "Successfully retrieved example",
        "word", exampleResponse.Word,
    )

    return &exampleResponse, nil
}

func NewExampleHttpRepository() domain.ExampleHttpRepository {
    return &exampleHttpRepository{}
}

pkg : Contém adaptadores para entrada e saída de dados, além da configuração de injeção de dependência.

adapter : Implementa a instrumentação, métricas e endpoints REST.
di : Configura a injeção de dependência, criando instâncias dos controladores e casos de uso.

./pkg/adapter/instrumentation/instrumentation.go

package instrumentation

import (
    "context"
    "errors"
    "os"
    "time"

    "go.opentelemetry.io/contrib/bridges/otelslog"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
    "go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/log/global"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/sdk/log"
    "go.opentelemetry.io/otel/sdk/metric"
    "go.opentelemetry.io/otel/sdk/resource"
    "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
)

const Name = "github.com/booscaa/observability-go-example/example-word"

var (
    Tracer = otel.Tracer(Name)
    Meter  = otel.Meter(Name)
    Logger = otelslog.NewLogger(Name)
)

func Initialize(ctx context.Context) (func(context.Context) error, error) {
    return setupOTelSDK(ctx)
}

func setupOTelSDK(ctx context.Context) (shutdown func(context.Context) error, err error) {
    var shutdownFuncs []func(context.Context) error

    shutdown = func(ctx context.Context) error {
        var err error
        for _, fn := range shutdownFuncs {
            err = errors.Join(err, fn(ctx))
        }
        shutdownFuncs = nil
        return err
    }

    handleErr := func(inErr error) {
        err = errors.Join(inErr, shutdown(ctx))
    }

    res := resource.NewWithAttributes(
        semconv.SchemaURL,
        semconv.ServiceNameKey.String(os.Getenv("SERVICE_NAME")),
        semconv.ServiceVersionKey.String("1.0.0"),
        semconv.ServiceInstanceIDKey.String("abcdef12345"),
    )

    prop := newPropagator()
    otel.SetTextMapPropagator(prop)

    tracerProvider, err := newTraceProvider(res)
    if err != nil {
        handleErr(err)
        return
    }
    shutdownFuncs = append(shutdownFuncs, tracerProvider.Shutdown)
    otel.SetTracerProvider(tracerProvider)

    meterProvider, err := newMeterProvider(res)
    if err != nil {
        handleErr(err)
        return
    }
    shutdownFuncs = append(shutdownFuncs, meterProvider.Shutdown)
    otel.SetMeterProvider(meterProvider)

    loggerProvider, err := newLoggerProvider(res)
    if err != nil {
        handleErr(err)
        return
    }
    shutdownFuncs = append(shutdownFuncs, loggerProvider.Shutdown)
    global.SetLoggerProvider(loggerProvider)

    return
}

func newPropagator() propagation.TextMapPropagator {
    return propagation.NewCompositeTextMapPropagator(
        propagation.TraceContext{},
        propagation.Baggage{},
    )
}

func newTraceProvider(resource *resource.Resource) (*trace.TracerProvider, error) {
    traceExporter, err := otlptracehttp.New(
        context.Background(),
        otlptracehttp.WithInsecure(),
        otlptracehttp.WithEndpoint("otel-collector:4318"),
    )
    if err != nil {
        return nil, err
    }

    traceProvider := trace.NewTracerProvider(
        trace.WithBatcher(traceExporter,
            trace.WithBatchTimeout(time.Second)),
        trace.WithResource(resource),
    )
    return traceProvider, nil
}

func newMeterProvider(resource *resource.Resource) (*metric.MeterProvider, error) {
    metricExporter, err := otlpmetrichttp.New(
        context.Background(),
        otlpmetrichttp.WithInsecure(),
        otlpmetrichttp.WithEndpoint("otel-collector:4318"),
    )
    if err != nil {
        return nil, err
    }

    meterProvider := metric.NewMeterProvider(
        metric.WithReader(metric.NewPeriodicReader(metricExporter,
            metric.WithInterval(3*time.Second)),
        ),
        metric.WithResource(resource),
    )
    return meterProvider, nil
}

func newLoggerProvider(resource *resource.Resource) (*log.LoggerProvider, error) {
    logExporter, err := otlploghttp.New(
        context.Background(),
        otlploghttp.WithInsecure(),
        otlploghttp.WithEndpoint("otel-collector:4318"),
    )
    if err != nil {
        return nil, err
    }

    loggerProvider := log.NewLoggerProvider(
        log.WithProcessor(log.NewBatchProcessor(logExporter)),
        log.WithResource(resource),
    )
    return loggerProvider, nil
}

./pkg/adapter/metric/metric.go

package metric

import "go.opentelemetry.io/otel/metric"

var (
    // Request metrics
    RequestCounter  metric.Int64Counter
    RequestDuration metric.Float64Histogram
    RequestInFlight metric.Int64UpDownCounter

    // Business metrics
    LetterCounter   metric.Int64Counter
    WordLengthGauge metric.Int64Gauge
)

func Initialize(meter metric.Meter) error {
    var err error

    RequestCounter, err = meter.Int64Counter(
        "request_total",
        metric.WithDescription("Total number of requests processed"),
        metric.WithUnit("1"),
    )
    if err != nil {
        return err
    }

    RequestDuration, err = meter.Float64Histogram(
        "request_duration_seconds",
        metric.WithDescription("Duration of requests"),
        metric.WithUnit("s"),
    )
    if err != nil {
        return err
    }

    RequestInFlight, err = meter.Int64UpDownCounter(
        "requests_in_flight",
        metric.WithDescription("Current number of requests being processed"),
        metric.WithUnit("1"),
    )
    if err != nil {
        return err
    }

    LetterCounter, err = meter.Int64Counter(
        "letter_concatenations_total",
        metric.WithDescription("Total number of letter concatenations"),
        metric.WithUnit("1"),
    )
    if err != nil {
        return err
    }

    WordLengthGauge, err = meter.Int64Gauge(
        "word_length",
        metric.WithDescription("Current length of the word"),
        metric.WithUnit("chars"),
    )
    if err != nil {
        return err
    }

    return nil
}

./pkg/adapter/rest/rest.go

package rest

import (
    "net/http"

    "github.com/booscaaa/observability-go-example/pkg/di"
)

func Initialize() {
    exampleController := di.NewExampleController()
    mux := http.NewServeMux()

    mux.HandleFunc("/", exampleController.GetExample)
    http.ListenAndServe(":8080", mux)
}

./pkg/di/di.go

package di

import (
    "github.com/booscaaa/observability-go-example/internals/domain/core/domain"
    "github.com/booscaaa/observability-go-example/internals/domain/usecase"
    "github.com/booscaaa/observability-go-example/internals/infra/controller"
    "github.com/booscaaa/observability-go-example/internals/infra/repository"
)

func NewExampleController() domain.ExampleController {
    exampleHttpRepository := repository.NewExampleHttpRepository()
    exampleUseCase := usecase.NewExampleHttpRepository(exampleHttpRepository)
    return controller.NewExampleController(exampleUseCase)
}

docker-compose.yaml : Define os serviços Docker necessários para executar a aplicação e as ferramentas de observabilidade. Inclui serviços como Traefik, Prometheus, Tempo, Loki, OpenTelemetry Collector e Grafana.

./docker-compose.yaml

services:
  traefik:
    container_name: traefik
    image: traefik:v2.10
    command:
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:8081"
    ports:
      - "8080:8080"
      - "8081:8081"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - observability-network

  service1:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: ${SERVICE1_NAME}
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.service1.rule=PathPrefix(`/service1`)"
      - "traefik.http.routers.service1.entrypoints=web"
      - "traefik.http.routers.service1.middlewares=strip-service1-prefix"
      - "traefik.http.middlewares.strip-service1-prefix.stripprefix.prefixes=/service1"
      - "traefik.http.services.service1.loadbalancer.server.port=8080"
    environment:
      - SERVICE_NAME=${SERVICE1_NAME}
      - SERVICE_CALL_URL=${SERVICE2_CALL_URL}
    networks:
      - observability-network

  service2:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: ${SERVICE2_NAME}
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.service2.rule=PathPrefix(`/service2`)"
      - "traefik.http.routers.service2.entrypoints=web"
      - "traefik.http.routers.service2.middlewares=strip-service2-prefix"
      - "traefik.http.middlewares.strip-service2-prefix.stripprefix.prefixes=/service2"
      - "traefik.http.services.service2.loadbalancer.server.port=8080"
    environment:
      - SERVICE_NAME=${SERVICE2_NAME}
      - SERVICE_CALL_URL=${SERVICE3_CALL_URL}
    networks:
      - observability-network

  service3:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: ${SERVICE3_NAME}
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.service3.rule=PathPrefix(`/service3`)"
      - "traefik.http.routers.service3.entrypoints=web"
      - "traefik.http.routers.service3.middlewares=strip-service3-prefix"
      - "traefik.http.middlewares.strip-service3-prefix.stripprefix.prefixes=/service3"
      - "traefik.http.services.service3.loadbalancer.server.port=8080"
    environment:
      - SERVICE_NAME=${SERVICE3_NAME}
    networks:
      - observability-network

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./config-files/prometheus.yaml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"
    networks:
      - observability-network

  tempo:
    image: grafana/tempo:latest
    container_name: tempo
    command: [ "-config.file=/etc/tempo.yaml" ]
    volumes:
      - ./config-files/tempo.yaml:/etc/tempo.yaml
      - tempo_data:/tmp/tempo
    ports:
      - "3200:3200"
      - "4319:4319"
    networks:
      - observability-network

  loki:
    image: grafana/loki:latest
    container_name: loki
    volumes:
      - ./config-files/loki.yaml:/etc/loki/loki-config.yaml
      - loki_data:/loki
    ports:
      - "3100:3100"
    networks:
      - observability-network

  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    container_name: otel-collector
    command: [ "--config=/etc/otel-collector-config.yaml" ]
    volumes:
      - ./config-files/otel.yaml:/etc/otel-collector-config.yaml
    ports:
      - "4317:4317" 
      - "4318:4318"
      - "8888:8888"
      - "8889:8889"
    networks:
      - observability-network
    depends_on:
      - tempo
      - loki
      - prometheus

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    depends_on:
      - prometheus
      - tempo
      - loki
    networks:
      - observability-network

networks:
  observability-network:
    driver: bridge

volumes:
  prometheus_data:
  tempo_data:
  loki_data:
  grafana_data:

Dockerfile : Especifica como construir a imagem Docker da aplicação Go, incluindo a instalação de dependências e a compilação do binário.

./Dockerfile

FROM golang:1.23

WORKDIR /app

COPY go.mod go.sum ./
RUN go mod tidy

COPY . .

RUN CGO_ENABLED=0 GOOS=linux go build -o main ./cmd/main.go

EXPOSE 8080

CMD ["./main", "serve"]

./go.mod

module github.com/booscaaa/observability-go-example

go 1.23.3

require (
    github.com/spf13/cobra v1.8.1
    go.opentelemetry.io/contrib/bridges/otelslog v0.9.0
    go.opentelemetry.io/otel v1.34.0
    go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.10.0
    go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.34.0
    go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.34.0
    go.opentelemetry.io/otel/log v0.10.0
    go.opentelemetry.io/otel/metric v1.34.0
    go.opentelemetry.io/otel/sdk v1.34.0
    go.opentelemetry.io/otel/sdk/log v0.10.0
    go.opentelemetry.io/otel/sdk/metric v1.34.0
)

Ports : Representadas pelas interfaces definidas no pacote domain . Elas definem os contratos que os adaptadores devem implementar para interagir com a lógica de negócio.
Adapters : Implementados nos pacotes infra e pkg . Eles adaptam as interfaces externas (como HTTP e OpenTelemetry) para as interfaces internas definidas no domínio.
Core : Contém a lógica de negócio central, implementada nos pacotes domain e usecase . Essa camada é independente de frameworks e bibliotecas externas, facilitando testes e manutenção.
Essa arquitetura permite que a aplicação seja facilmente extensível e testável, além de facilitar a integração com ferramentas de observabilidade para monitoramento e análise de desempenho.

Como Rodar o Projeto

Para executar o projeto, siga os passos abaixo:

Configure as variáveis de ambiente: Crie um arquivo .env na raiz do projeto e defina as variáveis necessárias, como SERVICE1_NAME, SERVICE2_CALL_URL, etc.

SERVICE1_NAME=service1
SERVICE2_CALL_URL=http://traefik:8081/service2

SERVICE2_NAME=service2
SERVICE3_CALL_URL=http://traefik:8081/service3

SERVICE3_NAME=service3

Construa e inicie os serviços Docker: Certifique-se de que o Docker está em execução e execute o comando abaixo para construir e iniciar os serviços definidos no docker-compose.yaml:

   docker-compose up --build

Acesse o serviço:
Após iniciar os serviços, você pode acessar o serviço principal em http://localhost:8081/service1.
Parar os serviços:
Para parar todos os serviços, execute:

   docker-compose down

Certifique-se de que todas as dependências estão instaladas e que o Docker está configurado corretamente antes de iniciar o projeto.

Configuração das Ferramentas de Observabilidade

Grafana:

Acesso: Após iniciar os serviços com Docker Compose, acesse o Grafana em http://localhost:3000 .
Login: Use as credenciais padrão ( admin / admin ) e altere a senha após o primeiro login.
Adicionar Fonte de Dados:
- Vá para "Data Sources" no menu de configurações (⚙️).
- Adicione Prometheus, Loki e Tempo como fontes de dados.
- Para Prometheus, use http://prometheus:9090 .
- Para Loki, use http://loki:3100 .
- Para Tempo, use http://tempo:3200 .

Criando Dashboards no Grafana

Criar um Novo Dashboard:

No menu lateral, clique em "+" e selecione "Dashboard".
Clique em "Add new panel" para adicionar um painel.

Configurar Painéis:

Métricas: Use a fonte de dados Prometheus para adicionar gráficos de métricas. Utilize consultas PromQL para definir as métricas. Exemplo:
```
  rate(request_duration_seconds_sum[5m]) / rate(request_duration_seconds_count[5m])
```
Logs: Use a fonte de dados Loki para adicionar painéis de logs. Utilize consultas LogQL para filtrar e visualizar logs.
Exemplo:
```
  {job="service1"}
```
Traces: Use a fonte de dados Tempo para adicionar painéis de traces. Visualize o fluxo de requisições e identifique gargalos.

Salvar o Dashboard:

Após configurar os painéis, clique em "Save dashboard" no canto superior direito.
Dê um nome ao dashboard e salve.

Visualizando Traces, Logs e Métricas

Traces: No Grafana, vá para "Explore" e selecione a fonte de dados Tempo. Realize consultas para visualizar traces específicos.

Logs: No Grafana, vá para "Explore" e selecione a fonte de dados Loki. Realize consultas para visualizar logs.

Métricas: No Grafana, use os painéis configurados para visualizar métricas em tempo real.

Recapitulando

Lembra que configuramos algumas métricas no path pkg/metrics/metrics.go?

RequestCounter, err = meter.Int64Counter(
        "request_total",
        metric.WithDescription("Total number of requests processed"),
        metric.WithUnit("1"),
    )
    if err != nil {
        return err
    }

    RequestDuration, err = meter.Float64Histogram(
        "request_duration_seconds",
        metric.WithDescription("Duration of requests"),
        metric.WithUnit("s"),
    )
    if err != nil {
        return err
    }

    RequestInFlight, err = meter.Int64UpDownCounter(
        "requests_in_flight",
        metric.WithDescription("Current number of requests being processed"),
        metric.WithUnit("1"),
    )
    if err != nil {
        return err
    }

    LetterCounter, err = meter.Int64Counter(
        "letter_concatenations_total",
        metric.WithDescription("Total number of letter concatenations"),
        metric.WithUnit("1"),
    )
    if err != nil {
        return err
    }

    WordLengthGauge, err = meter.Int64Gauge(
        "word_length",
        metric.WithDescription("Current length of the word"),
        metric.WithUnit("chars"),
    )
    if err != nil {
        return err
    }

Vamos montar um dashboard para acompanhar elas no Grafana.

Adicionando um dashboard, como vimos logo acima. Vamos adicionar os seguintes painéis:

Adicione uma visualização no seu dashboard, selecione o datasource prometheus e adicione a métrica request_total. Troque o tipo de chart para time series.

Adicione uma visualização no seu dashboard, selecione o datasource prometheus e adicione a métrica request_duration_seconds. Troque o tipo de chart para time series.

Adicione uma visualização no seu dashboard, selecione o datasource prometheus e adicione a métrica requests_in_flight. Troque o tipo de chart para gauge.

Adicione uma visualização no seu dashboard, selecione o datasource prometheus e adicione a métrica letter_concatenations_total. Troque o tipo de chart para time series.

Adicione uma visualização no seu dashboard, selecione o datasource prometheus e adicione a métrica word_length. Troque o tipo de chart para gauge.

E por fim teremos uma dashboard com todas as métricas para análise.

Ao seguir estas etapas detalhadamente, você estabelecerá um ambiente de observabilidade robusto e abrangente, capacitando-se a monitorar, analisar e visualizar de forma ainda mais eficaz o desempenho e o comportamento de suas aplicações Go.

Repositório: https://github.com/booscaaa/observability-go-example

Autenticação, Autorização, MFA e muito mais com Golang

Vinícius Boscardin — Mon, 14 Oct 2024 20:29:15 +0000

"Ó o cara falando de autenticação em pleno 2024!"

Sim! Vamos explorar como realizar fluxos de autenticação e autorização, e de quebra, entender a diferença entre estar autenticado e estar autorizado (spoiler: não é a mesma coisa!).

Neste texto, falaremos sobre três tópicos importantes:

JWT (o queridinho do mundo stateless)
OAuth (aquele que vive nas sombras das APIs de terceiros)
Casdoor (uma ferramenta que promete facilitar sua vida)

Autenticação vs. Autorização: Entendendo a Treta

Se você já trabalhou com autenticação, provavelmente ouviu algo como: “Fulano foi autenticado, então ele pode acessar tal recurso”. Calma lá! Estar autenticado é apenas dizer: “Sim, você é você mesmo!”. Agora, autorização é outra parada — significa: “Você, mesmo sendo você, tem permissão para mexer aqui?”. Percebe a diferença?

JWT: JSON Web Tokens no Role

JWT é aquele formato que a gente ama... até começar a lidar com expiração, rotação de tokens e as temidas brechas de segurança. O básico é simples:

token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
    "user": "fulano",
    "admin": true,
    "exp":  time.Now().Add(time.Hour * 24).Unix(),
})
tokenString, err := token.SignedString([]byte("s3cr3t"))
if err != nil {
    log.Fatal(err)
}
fmt.Println("Token:", tokenString)

Simples, né? Um JWT é basicamente um pacote de informações assinado. O problema é que, depois de gerado, ele vive por aí, distribuído na rede. Por isso, controle bem o tempo de expiração e o armazenamento dos tokens!

OAuth

Quando você quer integrar com outros serviços, tipo permitir que o usuário faça login com Google, GitHub, ou aquele app de delivery, você provavelmente usará OAuth. A ideia é a seguinte: o serviço terceiro confirma quem é o usuário e devolve um token para você, dizendo: “Ele é quem diz ser e está autorizado a fazer tal coisa”.

A sequência geralmente é assim:

O usuário clica em "Login com Google".
Redirecionamos ele para o Google para se autenticar.
Ele autoriza seu app a usar as informações.
Seu app recebe um access token e, se for bonzinho, também um refresh token.

Casdoor

Agora, se você quer uma solução completa para autenticação e autorização que já vem com UI e suporte a múltiplos protocolos (JWT, OAuth, etc.), Casdoor pode ser uma boa opção. Ele é uma plataforma open-source, escrita em GOLANG para autenticação e autorização, projetada para facilitar a gestão de usuários e permissões em aplicações modernas. Ele oferece suporte a múltiplos protocolos de autenticação, como JWT, OAuth, SAML, LDAP, e até integração com serviços de identidade populares, como Google, GitHub, WeChat, entre outros.

Com o Casdoor, você obtém:

Interface de gerenciamento de usuários pronta para uso.
Administração centralizada de permissões e roles.
Integração fácil com APIs e front-ends em diferentes linguagens, incluindo Golang.
Multi-fator de autenticação (MFA) disponível para aumentar a segurança.
Suporte a OAuth e SSO (Single Sign-On), ideal para aplicações que precisam conectar múltiplos serviços.

Além de ser fácil de configurar, o Casdoor é ideal para quem quer rapidez na implementação e precisa de uma interface intuitiva para gerenciar usuários e autorização sem muito esforço.

Você pode explorar mais sobre o projeto no GitHub do Casdoor ou no site oficial.

Como Rodar o Casdoor com Docker para Testes

Se você quer experimentar o Casdoor rapidamente, a maneira mais fácil é rodá-lo com Docker usando a imagem casbin/casdoor-all-in-one. Esse contêiner já vem com tudo configurado (servidor e banco de dados), facilitando o processo.

Passo 1: Rodar o Casdoor com Docker

Execute o seguinte comando no terminal:

docker run -p 8000:8000 casbin/casdoor-all-in-one

Isso irá:

Baixar a imagem do Casdoor (caso você ainda não tenha).
Rodar o servidor Casdoor na porta 8000.

Passo 2: Acessar a Interface do Casdoor

Assim que o contêiner estiver rodando, você pode acessar a interface de administração no navegador:

http://localhost:8000

Passo 3: Login na Interface de Admin

As credenciais padrão para o login são:

Usuário: admin
Senha: 123

Com isso, você poderá explorar as funcionalidades do Casdoor, configurar provedores de autenticação, criar usuários e definir permissões.

Configuração Básica do Casdoor

1. Criar uma Organização

As organizações em Casdoor são usadas para agrupar usuários e aplicações. Siga as etapas para criar sua primeira organização.

2. Criar Provedores

Provedores permitem que você configure como os usuários podem se autenticar (Google, GitHub, LDAP, etc.). Adicione um ou mais provedores de autenticação.

3. Criar Adapters

Os adapters permitem que você integre o Casdoor a sistemas de autorização externos. Crie um adapter para conectar seu sistema de permissões.

4. Criar uma Aplicação

As aplicações permitem vincular usuários e provedores a um contexto específico. Crie uma aplicação e associe a uma organização e provedores.

Passo 5: Adicionar os Providers na Aplicação

Após criar sua aplicação, você precisa associar os provedores (Providers) a ela. Isso garante que a aplicação saiba quais métodos de login estarão disponíveis para os usuários.

Acesse a aplicação que você criou.
Adicione os provedores configurados previamente à lista de Providers da aplicação.

Passo 6: Configurar o Layout do Login e do Cadastro

O Casdoor permite personalizar as telas de login e cadastro para que fiquem com a cara da sua aplicação.

Na interface de administração, acesse as configurações de UI da aplicação.
Personalize as cores, logos e textos para o login e o cadastro.
Visualize as mudanças em tempo real e salve.

Passo 7: Obter a URL para Autenticação

Após configurar tudo, você precisará da URL de autenticação para iniciar o fluxo de login a partir da sua aplicação.

Acesse a aplicação e copie a URL de autenticação disponível na aba de configurações.
Utilize essa URL para redirecionar usuários ao Casdoor quando precisarem se autenticar.

Exemplo de URL:

http://localhost:8000/login/oauth/authorize?client_id=[CLIENT_ID]&response_type=code&redirect_uri=http://localhost:9000/callback&scope=read&state=casdoor

Passo 8: Callback com o Code

Após o login bem-sucedido, o Casdoor redirecionará o usuário para a URL de callback com um code.

Exemplo de callback:

http://localhost:9000/callback?code=b1bf883de5a552aa43d6&state=casdoor

Esse code é temporário e será trocado por tokens para acessar recursos protegidos.

Passo 9: Obter Access Token, ID Token e Refresh Token

Após receber o code, você deve trocá-lo por tokens chamando a URL de token do Casdoor.

URL para Obter Tokens:

POST http://localhost:8000/api/login/oauth/access_token

Parâmetros necessários:

client_id: ID da aplicação.
client_secret: Segredo da aplicação.
code: O código recebido na URL de callback.
redirect_uri: A mesma URL usada no processo de login.
grant_type: "authorization_code".

A resposta incluirá:

{
  "access_token": "eyJhbGciOiJIUzI1...",
  "id_token": "eyJhbGciOiJIUzI1NiIs...",
  "refresh_token": "e5d92f3a...",
  "expires_in": 3600,
  "token_type": "Bearer"
}

Passo 10: Renovar o Access Token com o Refresh Token

Quando o access token expirar, você poderá obter um novo token usando o refresh token. Isso evita que o usuário precise fazer login novamente.

URL para Renovar o Token:

POST http://localhost:8000/api/login/oauth/refresh_token

Parâmetros necessários:

grant_type: "refresh_code".
client_secret: Segredo da aplicação.
client_secret: ID da aplicação.
refresh_token: O código JWT de refresh na URL de access_token.
scope: "read".

A resposta incluirá um novo json com tokens:

{
  "access_token": "eyJhbGciOiJIUzI1...",
  "id_token": "eyJhbGciOiJIUzI1NiIs...",
  "refresh_token": "e5d92f3a...",
  "expires_in": 3600,
  "token_type": "Bearer"
}

API Completa e SDKs para Integração

O Casdoor também disponibiliza uma API completa documentada no Swagger, permitindo que você crie telas de autenticação totalmente customizadas e adapte o fluxo de login às necessidades do seu projeto. Além disso, ele oferece SDKs para diversas tecnologias populares, como Flutter, React, Vue, Angular, e muito mais, facilitando a integração com diferentes stacks e plataformas. Com essas ferramentas, você tem flexibilidade para implementar autenticação de maneira rápida e eficiente, seja para aplicações web ou mobile.

GET http://localhost:8000/swagger/

Integração com Casbin para Autorização

Além da autenticação, o Casdoor pode ser integrado com o Casbin, uma poderosa biblioteca de autorização baseada em políticas. O Casbin permite definir quem pode acessar quais APIs e recursos de forma flexível, utilizando uma abordagem baseada em regras. Com suporte a diversos modelos, como ACL (Access Control List), RBAC (Role-Based Access Control) e ABAC (Attribute-Based Access Control), o Casbin facilita o controle granular de permissões.

A combinação de Casdoor para autenticação e Casbin para autorização oferece uma solução robusta para controlar o acesso em suas aplicações. Você pode, por exemplo, autenticar o usuário com Casdoor e utilizar o Casbin para verificar se ele tem permissão para acessar uma rota ou recurso específico.

Como Funciona o `Enforce` no Casbin

O método Enforce é o coração do Casbin. Ele é responsável por verificar se uma determinada solicitação de acesso deve ser permitida ou negada com base nas políticas definidas. O método recebe três parâmetros principais: sub (o sujeito, ou usuário), obj (o objeto, ou recurso) e act (a ação, como GET ou POST). Se a política permitir a combinação desses três elementos, o Casbin retorna true, indicando que o acesso é autorizado; caso contrário, retorna false.

Por exemplo, no código abaixo, o Casbin verificará se o usuário pode realizar uma ação específica no recurso solicitado:

ok, err := e.Enforce("alice", "/admin", "GET")
if err != nil {
    log.Fatal(err)
}
if ok {
    fmt.Println("Acesso permitido")
} else {
    fmt.Println("Acesso negado")
}

Esse processo garante que o acesso seja controlado dinamicamente com base nas permissões definidas na política, evitando que ações não autorizadas sejam executadas.

Exemplos de Uso em Controllers HTTP e Recursos

Aqui está um exemplo de como usar Casbin em uma aplicação Go para autorizar acesso a uma rota HTTP:

Exemplo de Middleware para Autorização com Casbin

package main

import (
    "github.com/casbin/casbin/v2"
    "net/http"
)

func authorize(e *casbin.Enforcer, sub, obj, act string) bool {
    ok, err := e.Enforce(sub, obj, act)
    if err != nil {
        return false
    }
    return ok
}

func middlewareAuth(e *casbin.Enforcer, next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        user := r.Header.Get("user") // Obtém o usuário do cabeçalho
        resource := r.URL.Path       // Recurso sendo acessado
        action := r.Method           // Método HTTP (GET, POST, etc.)

        if !authorize(e, user, resource, action) {
            http.Error(w, "Forbidden", http.StatusForbidden)
            return
        }

        next.ServeHTTP(w, r) // Continua se autorizado
    })
}

Exemplo de Política RBAC (Role-Based Access Control)

[request_definition]
r = sub, obj, act

[policy_definition]
p = sub, obj, act

[role_definition]
g = _, _

[policy]
p, admin, /admin, GET
p, user, /profile, GET

[role_assignment]
g, alice, admin
g, bob, user

Nesta política, o admin tem acesso à rota /admin e o user à rota /profile. O usuário Alice é atribuído ao papel de admin, enquanto Bob é um user.

Com essa abordagem, você pode criar sistemas seguros e escaláveis, combinando autenticação com o Casdoor e autorização com o Casbin.

Configuração no Casdoor

Passo 1: Criar o modelo

Passo 2: Definir o Enforce

E por fim, o MFA.

Como Configurar MFA no Casdoor

A Autenticação Multi-Fator (MFA) adiciona uma camada extra de segurança ao processo de login. Com ela, mesmo que alguém descubra a senha do usuário, será necessário um segundo fator para concluir a autenticação, como um código gerado por um app autenticador (Google Authenticator, Authy, etc.).

Passo 1: Adicionar autenticação 2 fatores no usuário.

Possível pela interface web ou implementando na API do casdoor para o usuário específico.

Passo 2: Realizar o Login

Ao realizar o login deve pedir o código de autenticação para validação.

Simples, não?

Conclusão

Autenticação e autorização são como aquelas engrenagens que, juntas, mantêm o sistema rodando redondo. A autenticação confirma quem é o usuário, enquanto a autorização define o que ele pode fazer. Não basta saber quem está logado; é preciso garantir que cada um só tenha acesso ao que realmente pode. É tipo festa: uma coisa é passar pela entrada, outra é conseguir entrar na área VIP.

Com o Casdoor, fica fácil gerenciar o processo de autenticação. Ele oferece uma variedade de opções, como login com Google, GitHub, além de integração com protocolos como JWT e OAuth. Já o Casbin é o cara que define as regras e garante que cada recurso seja acessado por quem tem permissão, funcionando como uma política de segurança que você controla.

Usar essas duas ferramentas juntas é uma solução poderosa. O Casdoor garante que só usuários legítimos passem pela porta, enquanto o Casbin faz o controle fino, autorizando ou bloqueando ações com base em regras personalizadas. E o melhor é que tudo isso pode ser integrado facilmente via API, com direito a documentação no Swagger e SDKs para várias tecnologias, como Flutter, React e Vue.

Com essa combinação, seu sistema fica bem organizado e seguro, sem complicação.

Go, Gemini e Alexa: Como criar automações para o seu dia a dia

Vinícius Boscardin — Mon, 01 Jul 2024 14:20:53 +0000

Vamos explorar como utilizar as tecnologias Go, Gemini e o uso da Alexa, para desenvolver automações úteis para o cotidiano. Utilizando um projeto prático como exemplo, mergulhamos nas possibilidades que essas ferramentas oferecem para automatizar tarefas e processos.

Cenário Hipotético:

Recomendações de Janta para a Alexa Integradas com o Gemini

Contexto

"Bido" deseja usar seu assistente virtual Alexa para receber recomendações de janta personalizadas. Para tornar isso possível, é necessário integrar a Alexa com o sistema de banco de dados, que armazena os cardápios de diferentes restaurantes. O banco de dados é alimentado por serviços independentes que atualizam constantemente as opções de menu.

Descrição do Problema

"Bido" quer que a Alexa forneça recomendações de jantar com base nas opções disponíveis nos restaurantes. Para isso, a Alexa precisa consultar um banco de dados PostgreSQL, onde o sistema armazena os cardápios de diversos restaurantes.

Requisitos

Integração com a Alexa:
- Desenvolver uma skill para a Alexa que permita a "Bido" pedir recomendações de jantar.
Banco de Dados PostgreSQL:
- Configurar um banco de dados PostgreSQL que armazene os cardápios dos restaurantes.
- Cada entrada no banco de dados deve incluir informações como nome do prato, preço, e restaurante.
Serviços de Alimentação de Dados:
- Criar serviços independentes que coletam e inserem dados de cardápios de restaurantes no banco de dados.
- Esses serviços podem são web scrapers.
Processo de Recomendação:
- Implementar um algoritmo de recomendação com os dados disponíveis no banco de dados.

Fluxo de Trabalho

Coleta de Dados:
- Serviços independentes coletam os cardápios dos restaurantes e os inserem no banco de dados PostgreSQL.
- O banco de dados é atualizado regularmente para garantir a precisão das informações.
Solicitação de Recomendação:
- "Bido" pede à Alexa uma recomendação de jantar.
- A Alexa coleta os dados e faz uma solicitação ao sistema.
Consulta ao Banco de Dados:
- O sistema consulta o banco de dados PostgreSQL para obter opções de cardápio.
- As informações são enviadas ao Gemini que por sua vez retorna o output da recomendação.
Resposta da Alexa:
- A Alexa apresenta a "Bido" uma lista de recomendações de jantar personalizadas, incluindo detalhes como nome do prato, preço e restaurante.

Desafios e Considerações

Garantir que os dados dos cardápios estejam sempre atualizados para fornecer recomendações precisas.

Diagrama

Vamos montar um diagrama de sequência, que contemple o nosso cenário. Temos que considerar que:

Ator (Usuário)
- Ativa a Alexa usando um comando de voz.
Alexa
- Recebe o comando para ativar uma skill específica, aqui rotulada como "prato rápido".
Skill
- Consulta o endpoint associado à skill ativada.
Webhook
- Ativado pela skill para realizar uma ação específica, como consultar dados.
Postgres
- Banco de dados que é consultado pelo webhook para buscar dados de produtos.
Lista de Produtos
- A lista de produtos recuperados do banco de dados Postgres é enviada de volta ao webhook.
Pedido de Análise
- Os dados dos produtos recuperados podem opcionalmente ser enviados para análise adicional por um LLM (Modelo de Linguagem de Grande Escala).
LLM
- Processa os dados de texto, para gerar uma nova saída com base na análise.
Saída Final
- A resposta processada é enviada de volta à skill, que então a comunica ao usuário através da Alexa.

Desenvolvimento

Sabendo do cenário e do fluxo de interação com as tecnologias, vamos começar desenvolver a solução. Precisamos de 2 serviços para tornar nossa aplicação mais rápida. Um serviço responsável pelo webhook e outro serviço para o scraper, garantindo que a base de dados se mantenha atualizada com os sites de pedidos.

Service 1

Atualiza produtos a cada 30 minutos.
Interage diretamente com os catálogos nos sites didios.menudino.com.br e potatos.menudino.com.br.

Service 2

Interage com Gemini.
Utiliza o Gemini para criar a resposta.
Banco de dados central que armazena informações usadas por outros serviços.

Software

ProductController

Descrição: Controlador principal que recebe solicitações HTTP relacionadas a solicitação da skill da alexa.
Entradas: Solicitações HTTP com dados de produto (ex: POST com detalhes que a skill fornece no corpo da requisição).
Saídas: Respostas HTTP baseadas no resultado das operações.

ProductCLI

Descrição: Interface de linha de comando para interação direta com operações de produtos.
Entradas: Comandos via terminal (ex: atualizar os produdos na base de dados).
Saídas: Resultados das operações exibidos no terminal.

Casos de Uso

ProductUseCase

Descrição: Caso de uso principal para operações com produtos, como consulta e atualização de informações de produto.
Entradas: Dados de produtos fornecidos pelo ProductController ou ProductCLI.
Saídas: Resultados das operações (sucesso, falha, dados do produto), que são enviados de volta para os respectivos iniciadores de solicitações.

ProductScraperUseCase

Descrição: Caso de uso específico para o scraping de dados de produtos de diferentes fontes externas.
Entradas: Comandos ou solicitações para iniciar o scraping.
Saídas: Dados de produtos que são armazenados nos repositórios ou retornados para atualizações em tempo real.

Repositórios

ProductDatabaseRepository

Descrição: Repositório responsável por gerenciar as operações de banco de dados relacionadas aos produtos.
Entradas: Requisições de armazenamento, atualização ou recuperação de dados de produtos.
Saídas: Dados de produtos recuperados ou status das operações de banco de dados.

ProductScraperRepository

Descrição: Repositório que lida com a integração e armazenamento dos dados obtidos através do scraping de produtos.
Entradas: Dados de produtos do ProductScraperUseCase.
Saídas: Status do armazenamento dos dados e dados integrados prontos para uso.

ProductLLMRepository

Descrição: Repositório para gerenciar operações específicas de aprendizado de máquina relacionadas a produtos, como recomendações.
Entradas: Dados de produtos para a análise.
Saídas: Resultados das análises de aprendizado de máquina, como recomendações.

Fluxos de Informação

De interfaces para casos de uso:
- ProductController e ProductCLI fornecem dados de entrada que são processados pelos casos de uso ProductUseCase e ProductScraperUseCase.
De casos de uso para repositórios:
- Dados são enviados dos casos de uso para os repositórios para armazenamento, recuperação ou processamento adicional.

Implementação

Primeiro passo é definir os contratos (interfaces) que serão implementados no sistema.



package contract

import (
    "context"
    "net/http"

    "github.com/booscaaa/go-gemini-gdg/api/internals/core/domain"
    "github.com/booscaaa/go-gemini-gdg/api/internals/core/dto"
)

type ProductScraperRepository interface {
    FindProducts(context.Context) ([]domain.Product, error)
}

type ProductDataBaseRepository interface {
    Fetch(context.Context) ([]domain.Product, error)
    Create(context.Context, domain.Product) (*domain.Product, error)
}

type ProductScraperUseCase interface {
    SeedProducts(context.Context) ([]domain.Product, error)
}

type ProductUseCase interface {
    GetMenu(context.Context) (*string, error)
    SearchForTips(context.Context) (*dto.AlexaResponse, error)
}

type ProductLLMRepository interface {
    GetMenu(context.Context, []domain.Product) (*string, error)
}

type ProductController interface {
    SearchForTips(http.ResponseWriter, *http.Request)
}

type ProductCLI interface {
    SeedProducts(context.Context)
}

Com as definições em mãos, precisamos realizar a implementação de cada interface com seus métodos.

Um exemplo da implementação do scraper



package repository

import (
    "context"
    "strconv"
    "strings"
    "time"

    "github.com/booscaaa/go-gemini-gdg/api/internals/core/contract"
    "github.com/booscaaa/go-gemini-gdg/api/internals/core/domain"
    "github.com/playwright-community/playwright-go"
)

const (
    DIDIOS_SITE = "https://didios.menudino.com/"
)

type didiosRepository struct {
    scrapper *playwright.Playwright
}

// FindProducts implements contract.ProductScraperRepository.
func (repository *didiosRepository) FindProducts(context.Context) ([]domain.Product, error) {
    products := []domain.Product{}

    browser, err := repository.scrapper.Chromium.Launch(playwright.BrowserTypeLaunchOptions{
        Headless: playwright.Bool(true),
    })
    if err != nil {
        return nil, err
    }

    context, err := browser.NewContext()
    if err != nil {
        return nil, err
    }

    page, err := context.NewPage()
    if err != nil {
        return nil, err
    }

    _, err = page.Goto(DIDIOS_SITE)
    if err != nil {
        return nil, err
    }

    categories, err := page.Locator("#cardapio > section.cardapio-body > div > div.categories > div").All()
    if err != nil {
        return nil, err
    }

    for _, category := range categories {
        category.ScrollIntoViewIfNeeded()

        time.Sleep(time.Millisecond * 500)

        cards, err := category.Locator("div:nth-child(2) > div > div").All()
        if err != nil {
            return nil, err
        }

        for _, card := range cards {
            card.ScrollIntoViewIfNeeded()

            productName, err := card.Locator("a > div > div.media-body > div.name > span").TextContent()
            if err != nil {
                return nil, err
            }

            productPrice, err := card.Locator("a > div > div.media-body > div.priceDescription > div").TextContent()
            if err != nil {
                return nil, err
            }

            productPrice = strings.ReplaceAll(productPrice, "R$ ", "")
            productPrice = strings.ReplaceAll(productPrice, ",", ".")

            product := domain.Product{
                Name:    productName,
                Company: "DIDIOS",
            }

            if price, err := strconv.ParseFloat(productPrice, 64); err == nil {
                product.Price = price
            }

            products = append(products, product)
        }
    }

    return products, nil
}

func NewDidiosRepository(scraper *playwright.Playwright) contract.ProductScraperRepository {
    return &didiosRepository{
        scrapper: scraper,
    }
}

Exemplo da implementação da integração com o Gemini



package repository

import (
    "bytes"
    "context"
    "fmt"
    "log"
    "text/tabwriter"

    "github.com/booscaaa/go-gemini-gdg/api/internals/core/contract"
    "github.com/booscaaa/go-gemini-gdg/api/internals/core/domain"
    "github.com/google/generative-ai-go/genai"
)

type geminiRepository struct {
    client *genai.Client
}

// GetMenu implements contract.ProductLLMRepository.
func (repository *geminiRepository) GetMenu(ctx context.Context, products []domain.Product) (*string, error) {
    model := repository.client.GenerativeModel("gemini-1.5-pro")

    chatSession := model.StartChat()

    var b bytes.Buffer

    writer := tabwriter.NewWriter(&b, 0, 8, 1, '\t', tabwriter.AlignRight)
    for _, product := range products {
        fmt.Fprintf(writer, "ID: %v\tNome: %s\tPreço: %v\tEmpresa: %s\n", product.ID, product.Name, product.Price, product.Company)
    }
    writer.Flush()

    prompt := fmt.Sprintf(` 
    Você é um atendente de restaurante.
    Sempre monte um cardápio para pedir em qualquer hora segundo essa lista de produtos: %s.
    Informe o que seria ideal pedir para comer e o preço total da compra.
    Detalhe de qual empresa é cada produto, bem como seu nome e preço.
    Mostre três opções de pedidos.
    Não dê mais informações do que o necessário.
    Sempre seja gentil.
    Seja sucinto!
    Você pode misturar os produtos de todas as empresas, se quiser.
    Diversifique sempre os pedidos para não ser toda vez a mesma coisa.
    Coloque uma pequena frase legal no final.
    Escreva os números por extenso sempre.
    Escreva tudo por extenso para leitura da Alexa.
    Escreva tudo em uma frase, respeitando o portugues.
    Não coloque caracteres especiais.
    Fale sempre em primeira pessoa.
                                                 `, b.String())

    res, err := chatSession.SendMessage(ctx, genai.Text(prompt))
    if err != nil {
        log.Fatal(err)
    }

    output := ""

    for _, cand := range res.Candidates {
        if cand.Content != nil {
            for _, part := range cand.Content.Parts {
                output = fmt.Sprintf("%s %s", output, part)
            }
        }
    }

    fmt.Println(output)

    return &output, nil
}

func NewGeminiRepository(client *genai.Client) contract.ProductLLMRepository {
    return &geminiRepository{
        client: client,
    }
}

A persistência dos dados no banco.



package database

import (
    "context"

    "github.com/booscaaa/go-gemini-gdg/api/internals/core/contract"
    "github.com/booscaaa/go-gemini-gdg/api/internals/core/domain"
    "github.com/jmoiron/sqlx"
)

type productDatabaseRepository struct {
    database *sqlx.DB
}

// Create implements contract.ProductDataBaseRepository.
func (repository *productDatabaseRepository) Create(ctx context.Context, input domain.Product) (*domain.Product, error) {
    output := domain.Product{}
    query := "INSERT INTO product (name, price, company, inserted_at) VALUES ($1, $2, $3, $4) RETURNING *;"

    err := repository.database.QueryRowxContext(
        ctx,
        query,
        input.Name,
        input.Price,
        input.Company,
        input.InsertedAt,
    ).StructScan(&output)
    if err != nil {
        return nil, err
    }

    return &output, nil
}

// Fetch implements contract.ProductDataBaseRepository.
func (repository *productDatabaseRepository) Fetch(ctx context.Context) ([]domain.Product, error) {
    output := []domain.Product{}
    query := `
        SELECT p.* FROM product p
        INNER JOIN (
            SELECT  MAX(inserted_at) AS MAXDATE
            FROM product
        ) p2
        ON p.inserted_at = p2.MAXDATE
    `

    err := repository.database.SelectContext(ctx, &output, query)
    if err != nil {
        return nil, err
    }

    return output, nil
}

func NewProductDatabase(database *sqlx.DB) contract.ProductDataBaseRepository {
    return &productDatabaseRepository{database: database}
}

E o nosso caso de uso do scraper.



package usecase

import (
    "context"
    "slices"
    "time"

    "github.com/booscaaa/go-gemini-gdg/api/internals/core/contract"
    "github.com/booscaaa/go-gemini-gdg/api/internals/core/domain"
)

type scraperUsecase struct {
    didiosRepository          contract.ProductScraperRepository
    potatosRepository         contract.ProductScraperRepository
    productDatabaseRepository contract.ProductDataBaseRepository
}

// SeedProducts implements contract.ProductScraperUseCase.
func (usecase *scraperUsecase) SeedProducts(ctx context.Context) ([]domain.Product, error) {
    currenteDate := time.Now()
    productsCreated := []domain.Product{}

    potatosProducts, err := usecase.potatosRepository.FindProducts(ctx)
    if err != nil {
        return nil, err
    }

    didiosProducts, err := usecase.didiosRepository.FindProducts(ctx)
    if err != nil {
        return nil, err
    }

    products := slices.Concat(potatosProducts, didiosProducts)

    for _, product := range products {
        product.InsertedAt = currenteDate
        productCreated, err := usecase.productDatabaseRepository.Create(ctx, product)
        if err != nil {
            return nil, err
        }

        productsCreated = append(productsCreated, *productCreated)
    }

    return productsCreated, nil
}

func NewProductScraperUsecase(
    didiosRepository contract.ProductScraperRepository,
    potatosRepository contract.ProductScraperRepository,
    productDatabaseRepository contract.ProductDataBaseRepository,
) contract.ProductScraperUseCase {
    return &scraperUsecase{
        didiosRepository:          didiosRepository,
        potatosRepository:         potatosRepository,
        productDatabaseRepository: productDatabaseRepository,
    }
}

O código completo da implementação está aqui:
https://github.com/booscaaa/go-gemini-gdg

Conclusão

Integrar a Alexa com o Gemini e um banco de dados PostgreSQL permitirá que o usuário receba recomendações de jantar personalizadas de maneira eficiente. Com serviços independentes alimentando o banco de dados, a solução garante atualizações constantes e precisas, proporcionando uma experiência de usuário satisfatória e personalizada. E, seguindo uma arquitetura limpa, sem acoplamentos, podemos incrementar funções na skill sem afetar o funcionamento atual.

Fly.io, alternativa ao Heroku

Vinícius Boscardin — Sun, 28 Aug 2022 16:38:37 +0000

No dia 25/08/2022 chegou o e-mail que o heroku vai remover alguns serviços gratuitos lá em novembro. Se você assim como eu usava muito ele para hospedar alguns testes, soluções do seu github e até mesmo algumas brincadeiras. Fly.io pode ser uma solução incrível substituindo o heroku.

Como migrar seus apps

Veremos um passo a passo para realizar a migração, tanto da aplicação quanto das esteiras de deploy no github actions.

Instalação

Crie uma conta em fly.io

Baixe e instale o SDK fornecido.

linux

curl -L https://fly.io/install.sh | sh

mac

brew install flyctl

windows

iwr https://fly.io/install.ps1 -useb | iex

Faça o login com o SDK

fly auth login

Deploy

Na pasta raiz do seu projeto rode

fly launch
# siga os passos de configuração necessários

Um arquivo chamado fly.toml será criado na raiz do projeto.

Altere a porta da aplicação.

[[services]]
  http_checks = []
  internal_port = 3000  #porta da sua aplicação aqui
  processes = ["app"]
  protocol = "tcp"

Por fim rode

fly launch
# or
fly deploy

Acesse o link disponibilizado no fly.io e seu app estará disponível.

Github actions

Altere o arquivo de workflow do seu app. Remova tudo referente ao Heroku.

Adicione no arquivo_deploy.yaml.

env:
  FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}

No seu job

- uses: superfly/flyctl-actions/setup-flyctl@master
- run: flyctl deploy --remote-only --detach

Exemplo

name: Deploy to fly.io app

on:
  create:
    tags:
      - v*

env:
  FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      - name: Config file access
        run: |
          rm -rf config.json
          touch config.json 
          json='{"database": {"url": "://$DB_USER:$DB_PASS@$DB_HOST:$DB_PORT/"},"server": {"port": ""}}'
          echo "$json" > config.json
          sed -i -e 's/$DB_PORT/'${{ secrets.DB_PORT }}'/g' config.json
          sed -i -e 's/$DB_USER/'${{ secrets.DB_USER }}'/g' config.json
          sed -i -e 's/$DB_PASS/'${{ secrets.DB_PASS }}'/g' config.json
          sed -i -e 's/$DB_HOST/'${{ secrets.DB_HOST }}'/g' config.json
          cat config.json

      - uses: superfly/flyctl-actions/setup-flyctl@master
      - run: flyctl deploy --remote-only --detach

Feito, com isso seu app já está disponível gratuitamente para uso da mesma forma que fazíamos no heroku.

Golang, observabilidade e métricas com SigNoz e OpenTelemetry

Vinícius Boscardin — Wed, 13 Jul 2022 19:36:58 +0000

Quem nunca passou por um aperto com uma api, endpoit, serviço ou qualquer coisa em produção e simplesmente não achou o problema ou demorou muito tempo para metrificar e descobrir o gargalo que fazia o sistema cair? É, aquela hora do dia que o sistema simplesmente ficava inutilizável e ninguém sabia explicar o motivo? Se você não passou por isso sempre vai ter a primeira vez... Brincadeiras a parte, hoje veremos como integrar um serviço criado com golang com o SigNoz usando OpenTelemetry

Bora lá! Primeiro passo é ter um serviço para metrificar! rsrs... Vamos criar algo muito simples para não perdermos tempo. O foco aqui é a integração com o SigNoz e não uma API completa com Golang.

Aplicação

Iniciaremos com:

mkdir go-signoz-otl
cd go-signoz-otl
go mod init github.com/booscaaa/go-signoz-otl

Vamos configurar nossa migration de produtos para o exemplo.

migrate create -ext sql -dir database/migrations -seq create_product_table

No nosso arquivo database/migrations/000001_create_product_table.up.sql

CREATE TABLE product(
    id serial primary key not null,
    name varchar(100) not null
);

INSERT INTO product (name) VALUES 
    ('Cadeira'),
    ('Mesa'),
    ('Toalha'),
    ('Fogão'),
    ('Batedeira'),
    ('Pia'),
    ('Torneira'),
    ('Forno'),
    ('Gaveta'),
    ('Copo');

Com a migration em mãos, bora criar já de início nosso conector com o postgres usando a lib sqlx.
adapter/postgres/connector.go

package postgres

import (
    "context"
    "log"

    "github.com/golang-migrate/migrate/v4"
    "github.com/jmoiron/sqlx"
    "github.com/spf13/viper"

    _ "github.com/golang-migrate/migrate/v4/database/postgres"
    _ "github.com/golang-migrate/migrate/v4/source/file"
    _ "github.com/lib/pq"
)

// GetConnection return connection pool from postgres drive SQLX
func GetConnection(context context.Context) *sqlx.DB {
    databaseURL := viper.GetString("database.url")

    db, err := sqlx.ConnectContext(
        context,
        "postgres",
        databaseURL,
    )
    if err != nil {
        log.Fatal(err)
    }

    return db
}

// RunMigrations run scripts on path database/migrations
func RunMigrations() {
    databaseURL := viper.GetString("database.url")
    m, err := migrate.New("file://database/migrations", databaseURL)
    if err != nil {
        log.Println(err)
    }

    if err := m.Up(); err != nil {
        log.Println(err)
    }
}

Vamos criar as abstrações e implementações no nosso dominio/adapters da aplicação.

core/domain/product.go

package domain

import (
    "context"

    "github.com/gin-gonic/gin"
)

// Product is entity of table product database column
type Product struct {
    ID   int32  `json:"id" db:"id"`
    Name string `json:"name" db:"name"`
}

// ProductService is a contract of http adapter layer
type ProductService interface {
    Fetch(*gin.Context)
}

// ProductUseCase is a contract of business rule layer
type ProductUseCase interface {
    Fetch(context.Context) (*[]Product, error)
}

// ProductRepository is a contract of database connection adapter layer
type ProductRepository interface {
    Fetch(context.Context) (*Product, error)
}

core/usecase/productusecase/new.go

package productusecase

import "github.com/booscaaa/go-signoz-otl/core/domain"

type usecase struct {
    repository domain.ProductRepository
}

// New returns contract implementation of ProductUseCase
func New(repository domain.ProductRepository) domain.ProductUseCase {
    return &usecase{
        repository: repository,
    }
}

core/usecase/productusecase/fetch.go

package productusecase

import (
    "context"

    "github.com/booscaaa/go-signoz-otl/core/domain"
)

func (usecase usecase) Fetch(ctx context.Context) (*[]domain.Product, error) {
    products, err := usecase.repository.Fetch(ctx)

    if err != nil {
        return nil, err
    }

    return products, err
}

adapter/postgres/productrepository/new.go

package productrepository

import (
    "github.com/booscaaa/go-signoz-otl/core/domain"
    "github.com/jmoiron/sqlx"
)

type repository struct {
    db *sqlx.DB
}

// New returns contract implementation of ProductRepository
func New(db *sqlx.DB) domain.ProductRepository {
    return &repository{
        db: db,
    }
}

adapter/postgres/productrepository/fetch.go

package productrepository

import (
    "context"

    "github.com/booscaaa/go-signoz-otl/core/domain"
)

func (repository repository) Fetch(ctx context.Context) (*[]domain.Product, error) {
    products := []domain.Product{}

    err := repository.db.SelectContext(ctx, &products, "SELECT * FROM product;")

    if err != nil {
        return nil, err
    }

    return &products, nil
}

adapter/http/productservice/new.go

package productservice

import "github.com/booscaaa/go-signoz-otl/core/domain"

type service struct {
    usecase domain.ProductUseCase
}

// New returns contract implementation of ProductService
func New(usecase domain.ProductUseCase) domain.ProductService {
    return &service{
        usecase: usecase,
    }
}

adapter/http/productservice/fetch.go

package productservice

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func (service service) Fetch(c *gin.Context) {
    products, err := service.usecase.Fetch(c.Request.Context())

    if err != nil {
        c.JSON(http.StatusInternalServerError, err)
        return
    }

    c.JSON(http.StatusOK, products)
}

di/product.go

package di

import (
    "github.com/booscaaa/go-signoz-otl/adapter/http/productservice"
    "github.com/booscaaa/go-signoz-otl/adapter/postgres/productrepository"
    "github.com/booscaaa/go-signoz-otl/core/domain"
    "github.com/booscaaa/go-signoz-otl/core/usecase/productusecase"
    "github.com/jmoiron/sqlx"
)

func ConfigProductDI(conn *sqlx.DB) domain.ProductService {
    productRepository := productrepository.New(conn)
    productUsecase := productusecase.New(productRepository)
    productService := productservice.New(productUsecase)

    return productService
}

adapter/http/main.go

package main

import (
    "context"

    "github.com/booscaaa/go-signoz-otl/adapter/postgres"
    "github.com/booscaaa/go-signoz-otl/di"
    "github.com/gin-gonic/gin"
    "github.com/spf13/viper"
)

func init() {
    viper.SetConfigFile(`config.json`)
    err := viper.ReadInConfig()
    if err != nil {
        panic(err)
    }
}

func main() {
    ctx := context.Background()
    conn := postgres.GetConnection(ctx)
    defer conn.Close()

    postgres.RunMigrations()

    productService := di.ConfigProductDI(conn)

    router := gin.Default()
    router.GET("/product", productService.Fetch)
    router.Run(":3000")
}

config.json

{
    "database": {
        "url": "postgres://postgres:postgres@localhost:5432/devtodb"
    },
    "server": {
        "port": "3000"
    },
    "otl": {
        "service_name": "devto_goapp",
        "otel_exporter_otlp_endpoint": "localhost:4317",
        "insecure_mode": true
    }
}

Por fim basta rodar a aplicação e ver se tudo ficou funcionando certinho!
No primeiro terminal:

go run adapter/http/main.go

No segundo terminal:

curl --location --request GET 'localhost:3000/product'

SigNoz

Com a aplicação pronta, vamos iniciar as devidas implementações para integrar as métricas com o SigNoz e ver a magia acontecer!
Primeiro passo então é instalarmos o SigNoz na nossa máquina, para isso usaremos o docker-compose.

git clone -b main https://github.com/SigNoz/signoz.git && cd signoz/deploy/

docker-compose -f docker/clickhouse-setup/docker-compose.yaml up -d

Feito isso basta acessar o endereço localhost:3301 no seu navegador.

Crie uma conta e acesse o painel do SigNoz.

No Dashboard inicial ainda não temos nada que nos interesse, mas fique a vontade para explorar os dados ja existentes da aplicação.

Por fim vamos realizar a integração e analisar os dados que serão mostrados no SigNoz.

Vamos começar alterando o conector com o banco de dados, criando um wrapper do sqlx com a lib otelsqlx, com isso vamos conseguir captar informações de queries que serão executadas no banco.

core/postgres/connector.go

package postgres

import (
    "context"
    "log"

    "github.com/golang-migrate/migrate/v4"
    "github.com/jmoiron/sqlx"
    "github.com/spf13/viper"
    "github.com/uptrace/opentelemetry-go-extra/otelsql"
    "github.com/uptrace/opentelemetry-go-extra/otelsqlx"
    semconv "go.opentelemetry.io/otel/semconv/v1.4.0"

    _ "github.com/golang-migrate/migrate/v4/database/postgres"
    _ "github.com/golang-migrate/migrate/v4/source/file"
    _ "github.com/lib/pq"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

// GetConnection return connection pool from postgres drive SQLX
func GetConnection(context context.Context, provider *sdktrace.TracerProvider) *sqlx.DB {
    databaseURL := viper.GetString("database.url")

    db, err := otelsqlx.ConnectContext(
        context,
        "postgres",
        databaseURL,
        otelsql.WithAttributes(semconv.DBSystemPostgreSQL),
        otelsql.WithTracerProvider(provider),
    )
    if err != nil {
        log.Fatal(err)
    }

    return db
}

// RunMigrations run scripts on path database/migrations
func RunMigrations() {
    databaseURL := viper.GetString("database.url")
    m, err := migrate.New("file://database/migrations", databaseURL)
    if err != nil {
        log.Println(err)
    }

    if err := m.Up(); err != nil {
        log.Println(err)
    }
}

Feito isso criaremos o arquivo util/tracer.go para inicializar a captura das informações.

package util

import (
    "context"
    "log"

    "github.com/spf13/viper"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    "go.opentelemetry.io/otel/sdk/resource"
    "google.golang.org/grpc/credentials"

    sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

var (
    ServiceName  = ""
    CollectorURL = ""
    Insecure     = false
)

func InitTracer() *sdktrace.TracerProvider {
    ServiceName = viper.GetString("otl.service_name")
    CollectorURL = viper.GetString("otl.otel_exporter_otlp_endpoint")
    Insecure = viper.GetBool("otl.insecure_mode")

    secureOption := otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
    if Insecure {
        secureOption = otlptracegrpc.WithInsecure()
    }

    ctx := context.Background()

    exporter, err := otlptrace.New(
        ctx,
        otlptracegrpc.NewClient(
            secureOption,
            otlptracegrpc.WithEndpoint(CollectorURL),
        ),
    )

    if err != nil {
        log.Fatal(err)
    }

    resources, err := resource.New(
        ctx,
        resource.WithAttributes(
            attribute.String("service.name", ServiceName),
            attribute.String("library.language", "go"),
        ),
    )

    if err != nil {
        log.Printf("Could not set resources: %v", err)
    }

    provider := sdktrace.NewTracerProvider(
        sdktrace.WithSampler(sdktrace.AlwaysSample()),
        sdktrace.WithBatcher(exporter),
        sdktrace.WithResource(resources),
    )

    otel.SetTracerProvider(
        provider,
    )
    return provider
}

E por último, mas não menos importante, vamos configurar o middleware para o gin no arquivo adapter/http/main.go

package main

import (
    "context"

    "github.com/booscaaa/go-signoz-otl/adapter/postgres"
    "github.com/booscaaa/go-signoz-otl/di"
    "github.com/booscaaa/go-signoz-otl/util"
    "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"

    "github.com/gin-gonic/gin"
    "github.com/spf13/viper"
)

func init() {
    viper.SetConfigFile(`config.json`)
    err := viper.ReadInConfig()
    if err != nil {
        panic(err)
    }
}

func main() {
    tracerProvider := util.InitTracer()
    ctx := context.Background()
    conn := postgres.GetConnection(ctx, tracerProvider)
    defer conn.Close()

    postgres.RunMigrations()

    productService := di.ConfigProductDI(conn)

    router := gin.Default()
    router.Use(otelgin.Middleware(util.ServiceName))
    router.GET("/product", productService.Fetch)
    router.Run(":3000")
}

Vamos rodar novamente a aplicação e criar um script para realizar diversas chamadas na api.
No primeiro terminal:

go run adapter/http/main.go

No segundo terminal:

while :
do
    curl --location --request GET 'localhost:3000/product'
done

Voltando para o painel do SigNoz basta esperar a aplicação aparecer no dashboard.

Clicando no app que acabou de aparecer já conseguimos analisar dados muito importantes como:

Media de tempo de cada request.
Quantidade de requests por segundo.
Qual o endpoint mais acessado da aplicação.
Porcentagem de erros que ocorreram.

E ao clicar em uma request que por ventura demorou muito para retornar ou deu erro, chegaremos a uma nova tela onde é possivel analisar o tempo interno de cada camada, além de ver exatamente a query que pode estar causando problemas na aplicação.

Publicando uma api GO no Digital Ocean Kubernetes

Vinícius Boscardin — Mon, 18 Apr 2022 22:30:18 +0000

Fala galerinha, veremos aqui como realizar um deploy de uma api go no cluster de Kubernetes da Digital Ocean.

Kubernetes (K8s) é um produto Open Source utilizado para automatizar a implantação, o dimensionamento e o gerenciamento de aplicativos em contêiner.

Bora lá

Primeiramente precisamos ter uma api funcional com Dockerfile configurado, né? rsrs Se você não sabe como criar uma api Go acompanha a série de Clean Architecture com Golang no dev.to.

Container Registry

Com sua api pronta bora colocar ela em um Container Registry privado. Usaremos também o serviço da Digital Ocean.

Crie uma conta na Digital Ocean e vá ao menu de Container Registry.

Depois criaremos um token de acesso para utilizarmos na autenticação do command line.

Gere o token e guarde ele em um local seguro!

Feito isso, baixo o command line interface da Digital Ocean (doctl) aqui: https://docs.digitalocean.com/reference/doctl/how-to/install/

Com o doctl instalado bem bonitinho. Vamos logar no nosso container registry.

doctl auth init -t <access_token>
doctl registry login

De volta na página do container registry, copie o endereço disponibilizado do repositório.

No terminal, na pasta da aplicação com o Dockerfile configurado rode:

docker build -t registry.digitalocean.com/booscaaa/clean-go .
docker push registry.digitalocean.com/booscaaa/clean-go

E pronto! Sua imagem está disponível no container registry da Digital Ocean.

Kubernetes

Vamos criar nosso primeiro cluster de Kubernetes, para isso vamos em:

Siga as instruções do Getting Started:

E por fim aguarde o cluster terminar de ser criado.

Com o cluster criado, vamos autenticar nosso registry para que o kubectl consiga baixar a imagem sem nenhum problema.

doctl registry kubernetes-manifest | kubectl apply -f -

kubectl create secret generic do-registry --from-file=.dockerconfigjson=docker-config.json --type=kubernetes.io/dockerconfigjson

Vamos criar um arquivo em kubernetes/api.yaml

apiVersion: v1
kind: Service
metadata:
  name: api
spec:
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  selector:
    app: api
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
spec:
  replicas: 4
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
      - name: api
        image: registry.digitalocean.com/booscaaa/clean-go
        resources:
          limits:
            memory: "128Mi"
            cpu: "100m"
        ports:
        - containerPort: 3000

Para aplicar a alteração vamos rodar.

kubectl apply -f kubernetes/api.yaml

Para ver o pod e os services rodando:

kubectl get pods
kubectl get services

Instalando o Nginx Ingress

Nossa api ainda não tem acesso externo, para isso vamos configurar o Nginx ingress para kubernetes no arquivo kubernetes/ingress.yaml.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api-ingress
spec:
  ingressClassName: nginx
  rules:
  - http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: api
            port:
              number: 80

Para aplicar as alterações basta rodar:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.1.2/deploy/static/provider/cloud/deploy.yaml

kubectl apply -f kubernetes/ingress.yaml

O que isso faz?

Isso acabou de criar um load balancer na Digital Ocean e expôs nossos services internos para a porta 80 do ip externo do load balancer.
Lembrando que os recursos a serem explorados com o Nginx Ingress são diversos. Um deles e muito útil é configurar o domínio/subdomínio da aplicação e, com o cert manager, gerar os certificados de SSL automaticamente.

E pronto. Api funcionado com o kubernetes!

Vue.js, Clean Architecture e Package by feature Pattern

Vinícius Boscardin — Wed, 13 Apr 2022 22:57:21 +0000

Lá vamos nós de novo falar de clean architecture... Mas agora não vamos mais falar de golang, e sim de Vue.js. Vamos implementar o fronted da nossa api da série de Clean Architecture com Golang em Vue.js.

Vamos lá! Nossa implementação do frontend deve ter os mesmos requisitos da nossa api:

Uma listagem de produtos
Um formulário para adicionar produtos na lista

Package by feature Pattern

Nesta estrutura de projeto, os pacotes contêm todas as classes necessárias para um recurso. A independência do pacote é assegurada colocando classes intimamente relacionadas no mesmo pacote. Aqui um post com um ótimo exemplo de como funciona.

Implementação

Primeira coisa que precisamos fazer é criar nosso projeto vue, ainda com o Vue 2 com typescript.

vue create clean-vue
cd clean-vue
vue add vuetify
npm i axios
npm i @types/axios --save-dev
npm run serve

Projetinho rodando liso, bora codar!

Vamos apagar a pasta src/components e estruturar o projeto da seguinte forma:

src
- di
- module
  - pagination
    - domain
      - model
  - product
    - const
    - components
    - repository
    - domain
      - model
      - usecase
    - controller
    - view

Agora tudo está dando erro, nada mais funciona! Calma lá, vamos estruturar nosso código que tudo se resolve. :D

Model

Primeira coisa é nós definirmos o model com o que volta da API no arquivo src/module/product/domain/model/product.ts.

import { AxiosResponse } from "axios"

interface ProductI {
    id?: number
    name?: string
    description?: string
    price?: number
}

class Product {
    id: number
    name: string
    description: string
    price: number

    constructor({ id = 0, name = "", description = "", price = 0.00 }: ProductI) {
        this.id = id
        this.name = name
        this.description = description
        this.price = price
    }
}

class ProductPagination {
    items: ProductI[]
    total: number

    constructor(response?: AxiosResponse) {
        this.items = response?.data?.items?.map((product: any) => new Product(product)) ?? []
        this.total = response?.data?.total ?? 0
    }
}

export { Product, ProductPagination }

E também o model de paginação default de toda a aplicação no arquivo src/module/pagination/domain/model/pagination.ts.

interface PaginationI {
    page: number
    itemsPerPage: number
    sort: string
    descending: string
    search: string
}

class Pagination {
    page: number
    itemsPerPage: number
    sort: string
    descending: string
    search: string

    constructor({ page, itemsPerPage, sort, descending, search }: PaginationI) {
        this.page = page
        this.itemsPerPage = itemsPerPage
        this.descending = descending
        this.search = search
        this.sort = sort
    }
}

export { Pagination }

Repository

Com nossos models prontos, podemos já preparar nosso repository para manipular os endpoint dos nossos produtos.
Criaremos o arquivo src/module/product/repository/fetchProductsRepository.ts.

import { Pagination } from '@/module/pagination/domain/model/pagination'
import { ProductPagination } from '../domain/model/product'
import { AxiosInstance } from 'axios'

interface FetchProductsRepository {
    (pagination: Pagination): Promise<ProductPagination>
}

const fetchProductsRepository = (axios: AxiosInstance): FetchProductsRepository => async (pagination: Pagination) => {
    const response = await axios.get("/product", {
        params: pagination
    })

    const productPagination = new ProductPagination(response)
    return productPagination
}

export { fetchProductsRepository, FetchProductsRepository }

E também criaremos o arquivo src/module/product/repository/createProductRepository.ts.

import { Product } from '../domain/model/product'
import { AxiosInstance } from 'axios'

interface CreateProductRepository {
    (product: Product): Promise<Product>
}

const createProductRepository = (axios: AxiosInstance): CreateProductRepository => async (product: Product) => {
    const response = await axios.post("/product", product)
    return new Product(response?.data)
}

export { createProductRepository, CreateProductRepository }

Usecase

Com nossos repositories criados, podemos implementar nosso usecase de produtos.
Criaremos o arquivo src/module/product/domain/usecase/fetchProductsUseCase.ts.

import { FetchProductsRepository } from "../../repository/fetchProductsRepository"
import { Pagination } from "@/module/pagination/domain/model/pagination"
import { ProductPagination } from "../model/product"
import { DataOptions } from "vuetify"

interface FetchProductsUseCase {
    (options: DataOptions, search: string): Promise<ProductPagination>
}

const fetchProductsUseCase = (repository: FetchProductsRepository): FetchProductsUseCase => async (options: DataOptions, search: string) => {
    const pagination = new Pagination({
        descending: options.sortDesc.join(","),
        sort: options.sortBy.join(","),
        page: options.page,
        itemsPerPage: options.itemsPerPage,
        search: search,
    })

    const productPagination = await repository(pagination)
    return productPagination
}

export { fetchProductsUseCase, FetchProductsUseCase }

E também criaremos o arquivo src/module/product/domain/usecase/createProductUseCase.ts.

import { CreateProductRepository } from "../../repository/createProductRepository"
import { Product } from "../model/product"

interface CreateProductsUseCase {
    (product: Product): Promise<Product>
}

const createProductUseCase = (repository: CreateProductRepository): CreateProductsUseCase => async (product: Product) => {
    const productCreated = await repository(product)
    return productCreated
}

export { createProductUseCase, CreateProductsUseCase }

Controller

Com nossos usecases criados, podemos implementar nosso Controller no arquivo module/product/controller/productController.ts.

import { CreateProductsUseCase } from "../domain/usecase/createProductUseCase";
import { FetchProductsUseCase } from "../domain/usecase/fetchProductUseCase";
import { Product, ProductPagination } from "../domain/model/product";
import { headers } from "../const/header";

class ProductController {
    options: any
    public product = new Product({})
    public productPagination = new ProductPagination()
    public headers = headers
    public formDialog = false

    constructor(
        private context: any,
        private fetchProductsUseCase: FetchProductsUseCase,
        private createProductUseCase: CreateProductsUseCase
    ) { }

    async paginate() {
        this.productPagination = await this.fetchProductsUseCase(this.options, "")
    }

    async save() {
        if (this.context.$refs.productForm.$refs.form.validate()) {
            await this.createProductUseCase(this.product)
            this.cancel()
            this.paginate()
        }
    }

    cancel() {
        this.product = new Product({})
        this.context.$refs.productForm.$refs.form.resetValidation()
        this.formDialog = false
    }
}

export { ProductController }

Tudo pronto! Brincadeira... Estamos quase lá, vamos configurar nossa injeção de dependências. Para configurar a injeção de dependência do nosso product vamos criar um arquivo em module/di/di.ts.

import { fetchProductsRepository } from "../product/repository/fetchProductsRepository";
import { createProductRepository } from "../product/repository/createProductRepository";
import { createProductUseCase } from "../product/domain/usecase/createProductUseCase";
import { fetchProductsUseCase } from "../product/domain/usecase/fetchProductUseCase";
import { ProductController } from "../product/controller/productController";
import axios from "axios";

const axiosInstance = axios.create({
    baseURL: "https://clean-go.herokuapp.com",
    headers: {
        "Content-Type": "application/json"
    }
})

axiosInstance.interceptors.response.use((response) => response, async (err) => {
    const status = err.response ? err.response.status : null

    if (status === 500) {
        // Do something here or on any status code return
    }

    return Promise.reject(err);
});

// Implementation methods from products feature
const fetchProductsRepositoryImpl = fetchProductsRepository(axiosInstance)
const fetchProductsUseCaseImpl = fetchProductsUseCase(fetchProductsRepositoryImpl)
const createProductRepositoryImpl = createProductRepository(axiosInstance)
const createProductUseCaseImpl = createProductUseCase(createProductRepositoryImpl)

const productController = (context: any) => new ProductController(
    context,
    fetchProductsUseCaseImpl,
    createProductUseCaseImpl
)

export { productController }

Agora sim, bora para nossa tela! Fique a vontade para montar ela do jeito que quiser!

Criaremos o arquivo module/product/components/productTable.vue

<template>
  <v-card>
    <v-card-title>
      Products
      <v-spacer></v-spacer>
      <v-btn
        color="primary"
        @click="controller.formDialog = true"
      >
        <v-icon left>mdi-plus</v-icon>new
      </v-btn>
    </v-card-title>
    <v-card-text class="pa-0">
      <v-data-table
        dense
        :items="controller.productPagination.items"
        :headers="controller.headers"
        :options.sync="controller.options"
        @pagination="controller.paginate()"
        :server-items-length="controller.productPagination.total"
      ></v-data-table>
    </v-card-text>
  </v-card>
</template>

<script>
export default {
  props: {
    controller: {
      require: true,
    },
  },
};
</script>

E o arquivo module/product/components/productForm.vue

<template>
  <v-dialog
    persistent
    width="400"
    v-model="controller.formDialog"
  >
    <v-card>
      <v-card-title class="pa-0 pb-4">
        <v-toolbar
          flat
          dense
          color="primary"
          class="white--text"
        >
          New product
        </v-toolbar>
      </v-card-title>
      <v-card-text>
        <v-form ref="form">
          <v-text-field
            label="Name"
            dense
            filled
            v-model="controller.product.name"
            :rules="[(v) => !!v || 'Required']"
          ></v-text-field>
          <v-text-field
            label="Price"
            dense
            filled
            v-model.number="controller.product.price"
            :rules="[(v) => !!v || 'Required']"
          ></v-text-field>
          <v-textarea
            label="Description"
            dense
            filled
            v-model="controller.product.description"
            :rules="[(v) => !!v || 'Required']"
          ></v-textarea>
        </v-form>
      </v-card-text>
      <v-card-actions>
        <v-btn
          @click="controller.cancel()"
          color="red"
          text
        >cancel</v-btn>
        <v-spacer></v-spacer>
        <v-btn
          color="primary"
          @click="controller.save()"
        >
          <v-icon left>mdi-content-save</v-icon>save
        </v-btn>
      </v-card-actions>
    </v-card>
  </v-dialog>
</template>

<script>
export default {
  props: {
    controller: {
      require: true,
    },
  },
};
</script>

E por fim criaremos o arquivo module/product/view/product.vue

<template>
  <v-app>
    <v-main>
      <v-row
        class="fill-height"
        justify="center"
        align="center"
      >
        <v-col
          cols="12"
          lg="6"
        >
          <product-table
            ref="productTable"
            :controller="controller"
          />
          <product-form
            ref="productForm"
            :controller="controller"
          />
        </v-col>
      </v-row>
    </v-main>
  </v-app>
</template>

<script>
import { productController } from "../../di/di";
import ProductTable from "../components/productTable";
import ProductForm from "../components/productForm";
export default {
  components: {
    ProductTable,
    ProductForm,
  },
  data: (context) => ({
    controller: productController(context),
  }),
};
</script>

E a estrutura final ficou:

Testando, 1..2..3.. Teste som!

Testando nossa api Go no Github Actions integrando com Codecov

Vinícius Boscardin — Sun, 27 Mar 2022 14:33:26 +0000

Com todo o fluxo de testes funcional que criamos lá na parte 2 da nossa série, precisamos agora botar isso para rodar sempre que algo acontecer no nosso repositório no github. Vamos configurar o arquivo .github/workflows/test.yaml.

on: [push, pull_request]
name: Run test suite
jobs:
  test:
    strategy:
      matrix:
        go-version: [1.18.x]
        os: [ubuntu-latest]
    runs-on: ${{ matrix.os }}
    steps:
    - name: Install Go
      uses: actions/setup-go@v2
      with:
        go-version: ${{ matrix.go-version }}
    - name: Checkout code
      uses: actions/checkout@v2
    - name: Download swaggo
      run: go install github.com/swaggo/swag/cmd/swag@latest
    - name: Install swaggo
      run: swag init -d adapter/http --parseDependency --parseInternal --parseDepth 2 -o adapter/http/docs
    - name: Test
      run: go mod tidy && go test ./... -coverprofile=coverage.txt -covermode=atomic

    - name: Upload coverage report
      uses: codecov/codecov-action@v1.0.2
      with:
        token: 276e28b3-208f-4012-ac00-594ff09c65a3
        file: ./coverage.txt
        flags: unittests
        name: codecov-umbrella

Precisamos capturar o token do Codecov para mandar o resultado dos testes, para isso vamos em codecov.io

Capturando o token e adicionando ele no arquivo .github/workflows/test.yaml já podemos realizar o commit da nossa alteração e ver se tudo vai funcionar.
Quando o actions terminar de rodar basta dar um F5 na página do codecov para observar o resultado do nosso coverage 100%.

Sua vez

Vai na fé! Acredito totalmente em você, independente do seu nível de conhecimento técnico, você vai criar a melhor api em GO.
Se você se deparar com problemas que não consegue resolver, sinta-se à vontade para entrar em contato. Vamos resolver isso juntos.

Publicando uma api REST Go no Heroku.

Vinícius Boscardin — Fri, 25 Mar 2022 21:00:41 +0000

Com nossa api pronta, testada e com a documentação em dia, chegou a hora de botar isso rodar em cloud né? Para isso vamos usar uma ferramente sensacional da SalesForce chamada Heroku.
Heroku é uma plataforma de nuvem como serviço que suporta várias linguagens de programação.

Configurando nossa API

Primeiro passo é nós configurar o arquivo docker para rodar no container do heroku. Vamos lá!
Na raiz do projeto crie um arquivo chamado Dockerfile. No arquivo vamos configurar um multstage build para deixar nossa imagem com somente os recursos necessários para rodar a aplicação.

FROM golang:latest AS builder
ADD . /go/api
WORKDIR /go/api

RUN go install github.com/swaggo/swag/cmd/swag@latest
RUN rm -rf deploy
RUN mkdir deploy
RUN swag init -d adapter/http --parseDependency --parseInternal --parseDepth 2 -o adapter/http/docs
RUN go mod tidy
RUN CGO_ENABLED=0 go build -o goapp adapter/http/main.go
RUN mv goapp ./deploy/goapp
RUN mv adapter/http/docs ./deploy/docs
RUN mv config.json ./deploy/config.json
RUN mv database ./deploy/database


FROM scratch AS production
COPY --from=builder /go/api/deploy /api/

WORKDIR /api
ENTRYPOINT  ./goapp

Com o Dockerfile pronto vamos configurar nosso deploy no github actions no arquivo .github/workflows/deploy.yaml.

name: Deploy to heroku app

on:
  create:
    tags:
      - v*

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      - name: Config file access
        run: |
          rm -rf config.json
          touch config.json 
          json='{"database": {"url": "://$DB_USER:$DB_PASS@$DB_HOST:$DB_PORT/$DB_NAME"},"server": {"port": ""}}'
          echo "$json" > config.json
          sed -i -e 's/$DB_PORT/'${{ secrets.DB_PORT }}'/g' config.json
          sed -i -e 's/$DB_USER/'${{ secrets.DB_USER }}'/g' config.json
          sed -i -e 's/$DB_PASS/'${{ secrets.DB_PASS }}'/g' config.json
          sed -i -e 's/$DB_NAME/'${{ secrets.DB_NAME }}'/g' config.json
          sed -i -e 's/$DB_HOST/'${{ secrets.DB_HOST }}'/g' config.json
          cat config.json

      - uses: akhileshns/heroku-deploy@v3.10.9
        with:
          heroku_api_key: ${{secrets.HEROKU_API_KEY}}
          heroku_app_name: "clean-go"
          heroku_email: ${{secrets.HEROKU_MAIL}}
          usedocker: true

Esse arquivo deploy.yaml precisa de algumas variaveis de ambiente para funcionar corretamente.

secrets.HEROKU_MAIL: Seu e-mail da conta heroku
secrets.HEROKU_API_KEY: Va nas configurações da sua conta

secrets.DB_PORT, secrets.DB_USER, secrets.DB_PASS, secrets.DB_NAME, secrets.DB_HOST: Adicione um addon com o postgres.

Copie as credencias do banco de dados e adicione nos secrets do github:

Crie uma release com uma tag com prefixo v:

E pronto! Seu action esta rodando para o deploy no heroku:

Quando ele ficar verdinho. Verifique o endpoint do app no heroku que vai estar rodando lisinho! :D

Sua vez

Como eu rodo os testes no Github Actions?

Próximo post vamos configurar e rodar os testes no actions integrando com a ferramenta do CodeCov.

Documentando uma api Go com Swagger

Vinícius Boscardin — Fri, 25 Mar 2022 14:38:59 +0000

Documentação. Documentação. Documentação. Não precisamos falar o quão importante é isso dentro de uma empresa, tenha ela o tamanho que for.
O Swagger é uma excelente ferramenta para realizar esse trabalho em qualquer API REST.

Vocês acreditam ser algo complicado e manual criar essa documentação? Vamos dar uma olhada.

Primeiramente, como o swagger está aí com o papel de documentar nossos métodos REST que estão expostos, vamos trabalhar com ele diretamente na nossa camada de service no adapter http.
Começamos editando o arquivo adapter/http/productservice/create.go.

// @Summary Create new product
// @Description Create new product
// @Tags product
// @Accept  json
// @Produce  json
// @Param product body dto.CreateProductRequest true "product"
// @Success 200 {object} domain.Product
// @Router /product [post]
func (service service) Create(response http.ResponseWriter, request *http.Request) {
    ...
}

Depois o arquivo adapter/http/productservice/fetch.go.

// @Summary Fetch products with server pagination
// @Description Fetch products with server pagination
// @Tags product
// @Accept  json
// @Produce  json
// @Param sort query string true "1,2"
// @Param descending query string true "true,false"
// @Param page query integer true "1"
// @Param itemsPerPage query integer true "10"
// @Param search query string false ""
// @Success 200 {object} domain.Pagination
// @Router /product [get]
func (service service) Fetch(response http.ResponseWriter, request *http.Request) {
    ...
}

E por fim o arquivo adapter/http/main.go.

// @title Clean GO API Docs
// @version 1.0.0
// @contact.name Vinícius Boscardin
// @license.name Apache 2.0
// @license.url http://www.apache.org/licenses/LICENSE-2.0.html
// @host localhost:port
// @BasePath /
func main() {
    ...
}

Bom, se nós rodarmos a api agora nada vai acontecer! Vamos botar essas tags para funcionar. Em go usaremos o CLI do Swaggo.
Com a lib instalada basta rodar na raiz do projeto o comando:

swag init -d adapter/http --parseDependency --parseInternal --parseDepth 2 -o adapter/http/docs

Isso vai gerar uma pasta chamada docs na pasta adapter/http.
Com isso vamos referenciar essa pasta na nossa rota no arquivo adapter/http/main.go.

package main

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

    "github.com/boooscaaa/clean-go/adapter/postgres"
    "github.com/boooscaaa/clean-go/di"
    "github.com/gorilla/mux"
    "github.com/spf13/viper"
    /*adicionar essa linha */ httpSwagger "github.com/swaggo/http-swagger" 

    /*adicionar essa linha */ _ "github.com/boooscaaa/clean-go/adapter/http/docs"
)

func init() {
    viper.SetConfigFile(`config.json`)
    err := viper.ReadInConfig()
    if err != nil {
        panic(err)
    }
}

// @title Clean GO API Docs
// @version 1.0.0
// @contact.name Vinícius Boscardin
// @license.name Apache 2.0
// @license.url http://www.apache.org/licenses/LICENSE-2.0.html
// @host localhost:port
// @BasePath /
func main() {
    ctx := context.Background()
    conn := postgres.GetConnection(ctx)
    defer conn.Close()

    postgres.RunMigrations()
    productService := di.ConfigProductDI(conn)

    router := mux.NewRouter()
    /*adicionar essa linha */ router.PathPrefix("/swagger").Handler(httpSwagger.WrapHandler)
    router.Handle("/product", http.HandlerFunc(productService.Create)).Methods("POST")
    router.Handle("/product", http.HandlerFunc(productService.Fetch)).Queries(
        "page", "{page}",
        "itemsPerPage", "{itemsPerPage}",
        "descending", "{descending}",
        "sort", "{sort}",
        "search", "{search}",
    ).Methods("GET")

    port := viper.GetString("server.port")
    log.Printf("LISTEN ON PORT: %v", port)
    http.ListenAndServe(fmt.Sprintf(":%v", port), router)
}

Prontinho! Fácil não? Agora é só acessar no navegador o link http://localhost:3000/swagger/index.html.

Sua vez

Como que faz deploy disso ai?

Próximo post vamos configurar um ambiente para deploy com docker lá no heroku.

Repositório

Testes unitários com Golang

Vinícius Boscardin — Thu, 24 Mar 2022 18:29:03 +0000

No post anterior criamos uma api completa seguindo os requisitos funcionais que definimos no começo. Esquecemos um detalhe muito importante, não acham? Onde que foi parar a cobertura de testes da api para garantir o funcionamento do código?

Nesse post veremos como implementar os testes unitários em uma arquitetura clean, vamos analisar como fica fácil testar e mockar qualquer coisa. Bora lá!

DTO (Data transfer object)

Vamos escrever nossos primeiros testes na nossa camada de transferência de dados. Primeiro passo é criar um arquivo core/dto/pagination_test.go.



package dto_test

import (
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/boooscaaa/clean-go/core/dto"

    "github.com/stretchr/testify/require"
)

func TestFromValuePaginationRequestParams(t *testing.T) {
    fakeRequest := httptest.NewRequest(http.MethodGet, "/product", nil)
    queryStringParams := fakeRequest.URL.Query()
    queryStringParams.Add("page", "1")
    queryStringParams.Add("itemsPerPage", "10")
    queryStringParams.Add("sort", "")
    queryStringParams.Add("descending", "")
    queryStringParams.Add("search", "")
    fakeRequest.URL.RawQuery = queryStringParams.Encode()

    paginationRequest, err := dto.FromValuePaginationRequestParams(fakeRequest)

    require.Nil(t, err)
    require.Equal(t, paginationRequest.Page, 1)
    require.Equal(t, paginationRequest.ItemsPerPage, 10)
    require.Equal(t, paginationRequest.Sort, []string{""})
    require.Equal(t, paginationRequest.Descending, []string{""})
    require.Equal(t, paginationRequest.Search, "")
}

Para executar o teste basta rodar



go test ./...

Para executar no "modo verboso"



go test ./... -v

Mas, o mais interessante é gerar nosso arquivo para visualizar o coverage do arquivo com:



go test -coverprofile cover.out ./...
go tool cover -html=cover.out -o cover.html

Feito isso basta abrir o arquivo cover.html no navegador e ele vai mostrar todas as linhas com cobertura de testes em verde e todas sem cobertura em vermelho.

Legal, não?

Bora deixar essa api com 100% de coverage então!!!
Vamos testar ainda no nosso DTO o arquivo product em core/dto/product_test.go.



package dto_test

import (
    "encoding/json"
    "strings"
    "testing"

    "github.com/boooscaaa/clean-go/core/dto"
    "github.com/bxcodec/faker/v3"

    "github.com/stretchr/testify/require"
)

func TestFromJSONCreateProductRequest(t *testing.T) {
    fakeItem := dto.CreateProductRequest{}
    faker.FakeData(&fakeItem)

    json, err := json.Marshal(fakeItem)
    require.Nil(t, err)

    itemRequest, err := dto.FromJSONCreateProductRequest(strings.NewReader(string(json)))

    require.Nil(t, err)
    require.Equal(t, itemRequest.Name, fakeItem.Name)
    require.Equal(t, itemRequest.Price, fakeItem.Price)
    require.Equal(t, itemRequest.Description, fakeItem.Description)
}

func TestFromJSONCreateProductRequest_JSONDecodeError(t *testing.T) {
    itemRequest, err := dto.FromJSONCreateProductRequest(strings.NewReader("{"))

    require.NotNil(t, err)
    require.Nil(t, itemRequest)
}

Repository

Com nosso DTO devidamente testado vamos para o repository em adapter/postgres/productrepository/create_test.go.



package productrepository_test

import (
    "fmt"
    "testing"

    "github.com/boooscaaa/clean-go/adapter/postgres/productrepository"
    "github.com/boooscaaa/clean-go/core/domain"
    "github.com/boooscaaa/clean-go/core/dto"
    "github.com/bxcodec/faker/v3"
    "github.com/pashagolub/pgxmock"
    "github.com/stretchr/testify/require"
)

func setupCreate() ([]string, dto.CreateProductRequest, domain.Product, pgxmock.PgxPoolIface) {
    cols := []string{"id", "name", "price", "description"}
    fakeProductRequest := dto.CreateProductRequest{}
    fakeProductDBResponse := domain.Product{}
    faker.FakeData(&fakeProductRequest)
    faker.FakeData(&fakeProductDBResponse)

    mock, _ := pgxmock.NewPool()

    return cols, fakeProductRequest, fakeProductDBResponse, mock
}

func TestCreate(t *testing.T) {
    cols, fakeProductRequest, fakeProductDBResponse, mock := setupCreate()
    defer mock.Close()

    mock.ExpectQuery("INSERT INTO product (.+)").WithArgs(
        fakeProductRequest.Name,
        fakeProductRequest.Price,
        fakeProductRequest.Description,
    ).WillReturnRows(pgxmock.NewRows(cols).AddRow(
        fakeProductDBResponse.ID,
        fakeProductDBResponse.Name,
        fakeProductDBResponse.Price,
        fakeProductDBResponse.Description,
    ))

    sut := productrepository.New(mock)
    product, err := sut.Create(&fakeProductRequest)

    if err := mock.ExpectationsWereMet(); err != nil {
        t.Errorf("there were unfulfilled expectations: %s", err)
    }

    require.Nil(t, err)
    require.NotEmpty(t, product.ID)
    require.Equal(t, product.Name, fakeProductDBResponse.Name)
    require.Equal(t, product.Price, fakeProductDBResponse.Price)
    require.Equal(t, product.Description, fakeProductDBResponse.Description)
}

func TestCreate_DBError(t *testing.T) {
    _, fakeProductRequest, _, mock := setupCreate()
    defer mock.Close()

    mock.ExpectQuery("INSERT INTO product (.+)").WithArgs(
        fakeProductRequest.Name,
        fakeProductRequest.Price,
        fakeProductRequest.Description,
    ).WillReturnError(fmt.Errorf("ANY DATABASE ERROR"))

    sut := productrepository.New(mock)
    product, err := sut.Create(&fakeProductRequest)

    if err := mock.ExpectationsWereMet(); err != nil {
        t.Errorf("there were unfulfilled expectations: %s", err)
    }

    require.NotNil(t, err)
    require.Nil(t, product)
}

Por fim no nosso repository o arquivo adapter/postgres/productrepository/fetch_test.go.



package productrepository_test

import (
    "fmt"
    "testing"

    "github.com/boooscaaa/clean-go/adapter/postgres/productrepository"
    "github.com/boooscaaa/clean-go/core/domain"
    "github.com/boooscaaa/clean-go/core/dto"
    "github.com/bxcodec/faker/v3"
    "github.com/pashagolub/pgxmock"
    "github.com/stretchr/testify/require"
)

func setupFetch() ([]string, dto.PaginationRequestParms, domain.Product, pgxmock.PgxPoolIface) {
    cols := []string{"id", "name", "price", "description"}
    fakePaginationRequestParams := dto.PaginationRequestParms{
        Page:         1,
        ItemsPerPage: 10,
        Sort:         nil,
        Descending:   nil,
        Search:       "",
    }
    fakeProductDBResponse := domain.Product{}
    faker.FakeData(&fakeProductDBResponse)

    mock, _ := pgxmock.NewPool()

    return cols, fakePaginationRequestParams, fakeProductDBResponse, mock
}

func TestFetch(t *testing.T) {
    cols, fakePaginationRequestParams, fakeProductDBResponse, mock := setupFetch()
    defer mock.Close()

    mock.ExpectQuery("SELECT (.+) FROM product").
        WillReturnRows(pgxmock.NewRows(cols).AddRow(
            fakeProductDBResponse.ID,
            fakeProductDBResponse.Name,
            fakeProductDBResponse.Price,
            fakeProductDBResponse.Description,
        ))

    mock.ExpectQuery("SELECT COUNT(.+) FROM product").
        WillReturnRows(pgxmock.NewRows([]string{"count"}).AddRow(int32(1)))

    sut := productrepository.New(mock)
    products, err := sut.Fetch(&fakePaginationRequestParams)

    require.Nil(t, err)

    if err := mock.ExpectationsWereMet(); err != nil {
        t.Errorf("there were unfulfilled expectations: %s", err)
    }

    for _, product := range products.Items.([]domain.Product) {
        require.Nil(t, err)
        require.NotEmpty(t, product.ID)
        require.Equal(t, product.Name, fakeProductDBResponse.Name)
        require.Equal(t, product.Price, fakeProductDBResponse.Price)
        require.Equal(t, product.Description, fakeProductDBResponse.Description)
    }
}

func TestFetch_QueryError(t *testing.T) {
    _, fakePaginationRequestParams, _, mock := setupFetch()
    defer mock.Close()

    mock.ExpectQuery("SELECT (.+) FROM product").
        WillReturnError(fmt.Errorf("ANY QUERY ERROR"))

    sut := productrepository.New(mock)
    products, err := sut.Fetch(&fakePaginationRequestParams)

    require.NotNil(t, err)

    if err := mock.ExpectationsWereMet(); err != nil {
        t.Errorf("there were unfulfilled expectations: %s", err)
    }

    require.Nil(t, products)
}

func TestFetch_QueryCountError(t *testing.T) {
    cols, fakePaginationRequestParams, fakeProductDBResponse, mock := setupFetch()
    defer mock.Close()

    mock.ExpectQuery("SELECT (.+) FROM product").
        WillReturnRows(pgxmock.NewRows(cols).AddRow(
            fakeProductDBResponse.ID,
            fakeProductDBResponse.Name,
            fakeProductDBResponse.Price,
            fakeProductDBResponse.Description,
        ))

    mock.ExpectQuery("SELECT COUNT(.+) FROM product").
        WillReturnError(fmt.Errorf("ANY QUERY COUNT ERROR"))

    sut := productrepository.New(mock)
    products, err := sut.Fetch(&fakePaginationRequestParams)

    require.NotNil(t, err)

    if err := mock.ExpectationsWereMet(); err != nil {
        t.Errorf("there were unfulfilled expectations: %s", err)
    }
    require.Nil(t, products)
}

UseCase

Ropository testado, bora pro usecase! Aqui temos uma pequena diferença, para mockar nosso repository e não gerar conexões externas no banco de dados ao rodar os testes, vamos usar a lib mockgen para criar nossos dubles de teste.

Após instalado, rode o comando na raiz do projeto:



mockgen -source=core/domain/product.go -destination=core/domain/mocks/fakeproduct.go -package=mocks

Agora sim! Vamos mockar nosso repository e criar nossos testes na camada de regra de negócio.
Primeiro vamos testar o arquivo core/usecase/productusecase/create_test.go.



package productusecase_test

import (
    "fmt"
    "testing"

    "github.com/boooscaaa/clean-go/core/domain"
    "github.com/boooscaaa/clean-go/core/domain/mocks"
    "github.com/boooscaaa/clean-go/core/dto"
    "github.com/boooscaaa/clean-go/core/usecase/productusecase"
    "github.com/bxcodec/faker/v3"
    "github.com/golang/mock/gomock"
    "github.com/stretchr/testify/require"
)

func TestCreate(t *testing.T) {
    fakeRequestProduct := dto.CreateProductRequest{}
    fakeDBProduct := domain.Product{}
    faker.FakeData(&fakeRequestProduct)
    faker.FakeData(&fakeDBProduct)

    mockCtrl := gomock.NewController(t)
    defer mockCtrl.Finish()
    mockProductRepository := mocks.NewMockProductRepository(mockCtrl)
    mockProductRepository.EXPECT().Create(&fakeRequestProduct).Return(&fakeDBProduct, nil)

    sut := productusecase.New(mockProductRepository)
    product, err := sut.Create(&fakeRequestProduct)

    require.Nil(t, err)
    require.NotEmpty(t, product.ID)
    require.Equal(t, product.Name, fakeDBProduct.Name)
    require.Equal(t, product.Price, fakeDBProduct.Price)
    require.Equal(t, product.Description, fakeDBProduct.Description)
}

func TestCreate_Error(t *testing.T) {
    fakeRequestProduct := dto.CreateProductRequest{}
    faker.FakeData(&fakeRequestProduct)

    mockCtrl := gomock.NewController(t)
    defer mockCtrl.Finish()
    mockProductRepository := mocks.NewMockProductRepository(mockCtrl)
    mockProductRepository.EXPECT().Create(&fakeRequestProduct).Return(nil, fmt.Errorf("ANY ERROR"))

    sut := productusecase.New(mockProductRepository)
    product, err := sut.Create(&fakeRequestProduct)

    require.NotNil(t, err)
    require.Nil(t, product)
}

Agora o arquivo core/usecase/productusecase/fetch_test.go.



package productusecase_test

import (
    "fmt"
    "testing"

    "github.com/boooscaaa/clean-go/core/domain"
    "github.com/boooscaaa/clean-go/core/domain/mocks"
    "github.com/boooscaaa/clean-go/core/dto"
    "github.com/boooscaaa/clean-go/core/usecase/productusecase"
    "github.com/bxcodec/faker/v3"
    "github.com/golang/mock/gomock"
    "github.com/stretchr/testify/require"
)

func TestFetch(t *testing.T) {
    fakePaginationRequestParams := dto.PaginationRequestParms{
        Page:         1,
        ItemsPerPage: 10,
        Sort:         nil,
        Descending:   nil,
        Search:       "",
    }
    fakeDBProduct := domain.Product{}

    faker.FakeData(&fakeDBProduct)

    mockCtrl := gomock.NewController(t)
    defer mockCtrl.Finish()
    mockProductRepository := mocks.NewMockProductRepository(mockCtrl)
    mockProductRepository.EXPECT().Fetch(&fakePaginationRequestParams).Return(&domain.Pagination{
        Items: []domain.Product{fakeDBProduct},
        Total: 1,
    }, nil)

    sut := productusecase.New(mockProductRepository)
    products, err := sut.Fetch(&fakePaginationRequestParams)

    require.Nil(t, err)

    for _, product := range products.Items.([]domain.Product) {
        require.Nil(t, err)
        require.NotEmpty(t, product.ID)
        require.Equal(t, product.Name, fakeDBProduct.Name)
        require.Equal(t, product.Price, fakeDBProduct.Price)
        require.Equal(t, product.Description, fakeDBProduct.Description)
    }
}

func TestFetch_Error(t *testing.T) {
    fakePaginationRequestParams := dto.PaginationRequestParms{
        Page:         1,
        ItemsPerPage: 10,
        Sort:         nil,
        Descending:   nil,
        Search:       "",
    }

    mockCtrl := gomock.NewController(t)
    defer mockCtrl.Finish()
    mockProductRepository := mocks.NewMockProductRepository(mockCtrl)
    mockProductRepository.EXPECT().Fetch(&fakePaginationRequestParams).Return(nil, fmt.Errorf("ANY ERROR"))

    sut := productusecase.New(mockProductRepository)
    product, err := sut.Fetch(&fakePaginationRequestParams)

    require.NotNil(t, err)
    require.Nil(t, product)
}

Service

Regra de negócio bombando! Bora pro service..
Crie o arquivo adapter/http/productservice/create_test.go.



package productservice_test

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/http/httptest"
    "strings"
    "testing"

    "github.com/boooscaaa/clean-go/adapter/http/productservice"
    "github.com/boooscaaa/clean-go/core/domain"
    "github.com/boooscaaa/clean-go/core/domain/mocks"
    "github.com/boooscaaa/clean-go/core/dto"
    "github.com/bxcodec/faker/v3"
    "github.com/golang/mock/gomock"
)

func setupCreate(t *testing.T) (dto.CreateProductRequest, domain.Product, *gomock.Controller) {
    fakeProductRequest := dto.CreateProductRequest{}
    fakeProduct := domain.Product{}
    faker.FakeData(&fakeProductRequest)
    faker.FakeData(&fakeProduct)

    mockCtrl := gomock.NewController(t)

    return fakeProductRequest, fakeProduct, mockCtrl
}

func TestCreate(t *testing.T) {
    fakeProductRequest, fakeProduct, mock := setupCreate(t)
    defer mock.Finish()
    mockProductUseCase := mocks.NewMockProductUseCase(mock)
    mockProductUseCase.EXPECT().Create(&fakeProductRequest).Return(&fakeProduct, nil)

    sut := productservice.New(mockProductUseCase)

    payload, _ := json.Marshal(fakeProductRequest)
    w := httptest.NewRecorder()
    r := httptest.NewRequest(http.MethodPost, "/product", strings.NewReader(string(payload)))
    r.Header.Set("Content-Type", "application/json")
    sut.Create(w, r)

    res := w.Result()
    defer res.Body.Close()

    if res.StatusCode != 200 {
        t.Errorf("status code is not correct")
    }
}

func TestCreate_JsonErrorFormater(t *testing.T) {
    _, _, mock := setupCreate(t)
    defer mock.Finish()
    mockProductUseCase := mocks.NewMockProductUseCase(mock)

    sut := productservice.New(mockProductUseCase)

    w := httptest.NewRecorder()
    r := httptest.NewRequest(http.MethodPost, "/product", strings.NewReader("{"))
    r.Header.Set("Content-Type", "application/json")
    sut.Create(w, r)

    res := w.Result()
    defer res.Body.Close()

    if res.StatusCode == 200 {
        t.Errorf("status code is not correct")
    }
}

func TestCreate_PorductError(t *testing.T) {
    fakeProductRequest, _, mock := setupCreate(t)
    defer mock.Finish()
    mockProductUseCase := mocks.NewMockProductUseCase(mock)
    mockProductUseCase.EXPECT().Create(&fakeProductRequest).Return(nil, fmt.Errorf("ANY ERROR"))

    sut := productservice.New(mockProductUseCase)

    payload, _ := json.Marshal(fakeProductRequest)
    w := httptest.NewRecorder()
    r := httptest.NewRequest(http.MethodPost, "/product", strings.NewReader(string(payload)))
    r.Header.Set("Content-Type", "application/json")
    sut.Create(w, r)

    res := w.Result()
    defer res.Body.Close()

    if res.StatusCode == 200 {
        t.Errorf("status code is not correct")
    }
}

E por fim o arquivo adapter/http/productservice/fetch_test.go.



package productservice_test

import (
    "fmt"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/boooscaaa/clean-go/adapter/http/productservice"
    "github.com/boooscaaa/clean-go/core/domain"
    "github.com/boooscaaa/clean-go/core/domain/mocks"
    "github.com/boooscaaa/clean-go/core/dto"
    "github.com/bxcodec/faker/v3"
    "github.com/golang/mock/gomock"
)

func setupFetch(t *testing.T) (dto.PaginationRequestParms, domain.Product, *gomock.Controller) {
    fakePaginationRequestParams := dto.PaginationRequestParms{
        Page:         1,
        ItemsPerPage: 10,
        Sort:         []string{""},
        Descending:   []string{""},
        Search:       "",
    }
    fakeProduct := domain.Product{}
    faker.FakeData(&fakeProduct)

    mockCtrl := gomock.NewController(t)

    return fakePaginationRequestParams, fakeProduct, mockCtrl
}

func TestFetch(t *testing.T) {
    fakePaginationRequestParams, fakeProduct, mock := setupFetch(t)
    defer mock.Finish()
    mockProductUseCase := mocks.NewMockProductUseCase(mock)
    mockProductUseCase.EXPECT().Fetch(&fakePaginationRequestParams).Return(&domain.Pagination{
        Items: []domain.Product{fakeProduct},
        Total: 1,
    }, nil)

    sut := productservice.New(mockProductUseCase)

    w := httptest.NewRecorder()
    r := httptest.NewRequest(http.MethodGet, "/product", nil)
    r.Header.Set("Content-Type", "application/json")
    queryStringParams := r.URL.Query()
    queryStringParams.Add("page", "1")
    queryStringParams.Add("itemsPerPage", "10")
    queryStringParams.Add("sort", "")
    queryStringParams.Add("descending", "")
    queryStringParams.Add("search", "")
    r.URL.RawQuery = queryStringParams.Encode()
    sut.Fetch(w, r)

    res := w.Result()
    defer res.Body.Close()

    if res.StatusCode != 200 {
        t.Errorf("status code is not correct")
    }
}

func TestFetch_PorductError(t *testing.T) {
    fakePaginationRequestParams, _, mock := setupFetch(t)
    defer mock.Finish()
    mockProductUseCase := mocks.NewMockProductUseCase(mock)
    mockProductUseCase.EXPECT().Fetch(&fakePaginationRequestParams).Return(nil, fmt.Errorf("ANY ERROR"))

    sut := productservice.New(mockProductUseCase)

    w := httptest.NewRecorder()
    r := httptest.NewRequest(http.MethodGet, "/product", nil)
    r.Header.Set("Content-Type", "application/json")
    queryStringParams := r.URL.Query()
    queryStringParams.Add("page", "1")
    queryStringParams.Add("itemsPerPage", "10")
    queryStringParams.Add("sort", "")
    queryStringParams.Add("descending", "")
    queryStringParams.Add("search", "")
    r.URL.RawQuery = queryStringParams.Encode()
    sut.Fetch(w, r)

    res := w.Result()
    defer res.Body.Close()

    if res.StatusCode == 200 {
        t.Errorf("status code is not correct")
    }
}

E agora? Agora nosso coverage está 100% contemplado.

Sua vez

Podia ter uma doc com Swagger e Openapi né?

Próximo post vamos ver o quão simples é fazer isso com Golang.

Repositório

DEV Community: Vinícius Boscardin

Gerenciando o Pull de Conexões do banco de dados com Golang

O que é um Pool de Conexões?

Como Funciona o Gerenciamento de Conexões no Go

Exemplo de Configuração de Pool

Estrutura sql.DBStats

Exemplo de Monitoramento do Pool de Conexões

Implementando Observabilidade em Aplicações Go com OpenTelemetry, Prometheus, Loki, Tempo e Grafana

Ferramentas de Observabilidade Utilizadas

OpenTelemetry

Prometheus

Loki

Tempo

Grafana

Vamos Colocar a Mão na Massa!

Pré-requisitos

Desafio de Implementação

Fluxo de Requisições

Arquitetura do Projeto

Estrutura do Projeto

Como Rodar o Projeto

Configuração das Ferramentas de Observabilidade

Criando Dashboards no Grafana

Visualizando Traces, Logs e Métricas

Recapitulando

Autenticação, Autorização, MFA e muito mais com Golang

Autenticação vs. Autorização: Entendendo a Treta

JWT: JSON Web Tokens no Role

OAuth

Casdoor

Como Rodar o Casdoor com Docker para Testes

Passo 1: Rodar o Casdoor com Docker

Passo 2: Acessar a Interface do Casdoor

Passo 3: Login na Interface de Admin

Configuração Básica do Casdoor

1. Criar uma Organização

2. Criar Provedores

3. Criar Adapters

4. Criar uma Aplicação

Passo 5: Adicionar os Providers na Aplicação

Passo 6: Configurar o Layout do Login e do Cadastro

Passo 7: Obter a URL para Autenticação

Passo 8: Callback com o Code

Passo 9: Obter Access Token, ID Token e Refresh Token

URL para Obter Tokens:

Passo 10: Renovar o Access Token com o Refresh Token

URL para Renovar o Token:

API Completa e SDKs para Integração

Integração com Casbin para Autorização

Como Funciona o Enforce no Casbin

Exemplos de Uso em Controllers HTTP e Recursos

Exemplo de Middleware para Autorização com Casbin

Exemplo de Política RBAC (Role-Based Access Control)

Configuração no Casdoor

Passo 1: Criar o modelo

Passo 2: Definir o Enforce

Como Configurar MFA no Casdoor

Passo 1: Adicionar autenticação 2 fatores no usuário.

Passo 2: Realizar o Login

Conclusão

Go, Gemini e Alexa: Como criar automações para o seu dia a dia

Cenário Hipotético:

Contexto

Descrição do Problema

Requisitos

Fluxo de Trabalho

Desafios e Considerações

Diagrama

Desenvolvimento

Service 1

Service 2

Software

ProductController

ProductCLI

Casos de Uso

ProductUseCase

ProductScraperUseCase

Repositórios

ProductDatabaseRepository

ProductScraperRepository

Estrutura `sql.DBStats`

Como Funciona o `Enforce` no Casbin