api-gateway-go

module
v0.0.0-...-2defda7 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 27, 2025 License: MIT

README ¶

API Gateway em Go

GitHub go.mod Go version Build Status Coverage License

Um API Gateway robusto, escalÔvel e de alto desempenho escrito em Go. Ideal para arquiteturas de microsserviços, fornecendo recursos como autenticação, rate limiting, circuit breaking, métricas e muito mais.

🌟 Recursos

  • Proxy Reverso: Encaminha requisiƧƵes para serviƧos de backend.
  • Autenticação: Valida tokens JWT e controla acesso a rotas protegidas.
  • Rate Limiting: Limita o nĆŗmero de requisiƧƵes por usuĆ”rio, IP ou rota.
  • Circuit Breaking: Evita sobrecarga de serviƧos downstream quando falham.
  • Caching: Reduz carga em serviƧos repetindo respostas previamente obtidas.
  • Monitoramento: MĆ©tricas detalhadas via Prometheus e dashboards Grafana.
  • Rastreamento: Rastreamento distribuĆ­do com OpenTelemetry.
  • Admin API: Interface para gerenciar rotas e configuraƧƵes.
  • Escalabilidade: Projetado para alta performance e baixo consumo de recursos.

šŸ“‹ PrĆ©-requisitos

  • Go 1.23 ou superior
  • Docker e Docker Compose (para desenvolvimento e teste)
  • Banco de dados compatĆ­vel (SQLite, PostgreSQL ou MySQL)
  • Redis (opcional, para cache distribuĆ­do)

šŸš€ InĆ­cio RĆ”pido

Instalação BÔsica
  # Clonar o repositório
  git clone https://github.com/diillson/api-gateway-go.git
  cd api-gateway-go
    
  # Instalar dependĆŖncias
  go mod download
    
  # Gerar arquivo de configuração
  go run cmd/genconfig/main.go --output config/config.yaml
    
  # Executar migraƧƵes
  go run cmd/apigateway/main.go migrate
  
  # Usando a ferramenta CLI incluĆ­da para criar admin
  go run cmd/tools/create_admin.go -username "admin" -password "senha123" --email "admin@example.com" -driver postgres -dsn "postgres://postgres:postgres@localhost:5432/apigateway?sslmode=disable"
    
  # Gerar token para acesso administrativo
  # Usando a ferramenta CLI incluĆ­da para gerar token
  go run cmd/tools/generate_token.go -user_id "ID GERADO AO CRIAR O USUƁRIO"
    
  # Iniciar o servidor
  go run cmd/apigateway/main.go server
Usando Docker Compose
    # Iniciar ambiente completo (API Gateway, PostgreSQL, Redis, Prometheus, Grafana)
    docker-compose up -d
    
    # Verificar logs
    docker-compose logs -f api-gateway
    
    # Parar todos os serviƧos
    docker-compose down

šŸ¤“ O API GATEWAY NO DETALHE 🤩

āš™ļø Configuração

O API Gateway pode ser configurado atravƩs de:

  1. Arquivo de configuração YAML
  2. VariƔveis de ambiente (prefixo AG_ )
  3. Flags de linha de comando
Exemplo de Configuração
    server:
       port: 8080  # Porta HTTP para o servidor (NĆ£o usada para ENV != development e TLS = true)
       host: "0.0.0.0"
       readTimeout: "5s"
       writeTimeout: "10s"
       idleTimeout: "30s"
       maxheaderbytes: 1048576
       tls: false
       certfile: /path/to/cert.pem
       keyfile: /path/to/key.pem
       baseurl: https://api.example.com
       domains:
         - api.example.com

    database:
       driver: postgres             # OpƧƵes: sqlite, postgres, mysql
       dsn: postgres://postgres:postgres@postgres:5432/apigateway?sslmode=disable    # Formato DSN especĆ­fico para cada driver
       maxIdleConns: 10
       maxOpenConns: 50
       connMaxLifetime: "1h"
       loglevel: warn
       slowthreshold: 200ms
       migrationdir: ./migrations
      # skipmigrations: true (Apenas usar se for pular as migraƧƵes pois default Ʃ false)       

    cache:
       enabled: true
       type: "memory"                # OpƧƵes: memory, redis
       ttl: "5m"                     # Tempo de vida padrão para itens no cache
    maxitems: 10000
    maxmemorymb: 100
    redis:  # ConfiguraƧƵes especƭficas para Redis
      address: localhost:6379  # EndereƧo do servidor Redis (host:port)
      password: ""
      db: 0
      poolsize: 10  # Número mÔximo de conexões no pool
      minidleconns: 5  # Número mínimo de conexões ociosas mantidas abertas
      maxretries: 3  # Número mÔximo de tentativas de reconexão
      readtimeout: 3s  # Timeout para operaƧƵes de leitura
      writetimeout: 3s  # Timeout para operaƧƵes de escrita
      dialtimeout: 5s  # Timeout para estabelecer nova conexão
      pooltimeout: 4s  # Timeout para obter conexão do pool
      idletimeout: 5m0s  # Tempo mÔximo que uma conexão pode ficar ociosa
      maxconnage: 30m0s  # Tempo mÔximo de vida da conexão
      connectionpoolname: ""   

    auth:
       enabled: true
       jwtsecret: "your-secret-key"  # Em produção, use variÔvel de ambiente
       tokenExpiration: "24h"
       refreshEnabled: true
       refreshDuration: "168h"
       adminUsers: ["admin"]
       passwordminlen: 8

    logging:
      level: info
      format: json
      outputpath: stdout
      errorpath: stderr
      production: true

    metrics:
      enabled: true
      prometheuspath: "/metrics"
      reportInterval: "15s"
      
    tracing:
      enabled: true
      provider: otlp
      endpoint: otel-collector:4317
      servicename: api-gateway
      samplingratio: 1.0      

    features:
       ratelimiter: true             # Ativar limitação de taxa
       circuitbreaker: true          # Ativar circuit breaker
       caching: true                 # Ativar cache de respostas
       healthcheck: true             # Ativar endpoints de health check
       adminapi: true                # Ativar API administrativa
       monitoring: true              # Ativar monitoramento
VariƔveis de Ambiente

    # ConfiguraƧƵes do servidor
    AG_SERVER_PORT=8080
    AG_SERVER_HOST=0.0.0.0
    
    # ConfiguraƧƵes do banco de dados
    AG_DATABASE_DRIVER=postgres
    AG_DATABASE_DSN=postgres://user:password@localhost:5432/apigateway
    
    # ConfiguraƧƵes de cache
    AG_CACHE_TYPE=redis
    AG_CACHE_ADDRESS=localhost:6379
    
    # Configurações de autenticação (importante!)
    AG_AUTH_JWT_SECRET_KEY=seu-segredo-seguro-aqui
    AG_AUTH_TOKENEXPIRATION=24h
    
    # Ativar/Desativar recursos
    AG_FEATURES_RATELIMITER=true
    AG_FEATURES_CIRCUITBREAKER=true
    AG_FEATURES_CACHING=true
    
    AG_SERVER_TLS=true                          # Habilitar TLS/HTTPS
    SERVER_DOMAINS=api.seudominio.com,outro.seudominio.com  # DomĆ­nios para Let's Encrypt
    LETSENCRYPT_EMAIL=seu@email.com             # Email para Let's Encrypt
    AG_SERVER_CERT_FILE=/path/to/cert.pem       # Opcional: Caminho para certificado
    AG_SERVER_KEY_FILE=/path/to/key.pem         # Opcional: Caminho para chave privada

šŸ”’ Autenticação e SeguranƧa

Gerando um Token JWT para Acesso Administrativo

Para acessar a Ôrea administrativa, você precisa gerar um usuÔrio Admin e um token JWT vÔlido:

    # Usando a ferramenta CLI incluĆ­da para gerar admin
    go run cmd/tools/create_admin.go -username "admin" -password "senha123" --email "admin@example.com" -driver postgres -dsn "postgres://postgres:postgres@localhost:5432/apigateway?sslmode=disable"
    
    # Usando a ferramenta CLI incluĆ­da para gerar token
    go run cmd/tools/generate_token.go -user_id "ID GERADO AO CRIAR O USUƁRIO"

šŸ”’ JWT API Gateway no Detalhe

Configurando o Segredo JWT
O segredo JWT Ć© usado para assinar e verificar tokens de autenticação. Ɖ crucial configurĆ”-lo corretamente para seguranƧa.

OpƧƵes para configurar o segredo JWT (em ordem de prioridade):

  1. Via variƔvel de ambiente:
      export JWT_SECRET_KEY=sua-chave-secreta-muito-longa-e-aleatoria
  1. Via variƔvel de ambiente com prefixo AG:
   export AG_AUTH_JWT_SECRET_KEY=sua-chave-secreta-muito-longa-e-aleatoria
  1. No arquivo de configuração config.yaml :
auth:
   jwtsecret: "sua-chave-secreta-muito-longa-e-aleatoria"

āš ļø Importante: O uso do valor padrĆ£o hardcoded Ć© apenas para desenvolvimento. Em ambientes de produção, sempre configure um segredo Ćŗnico e seguro.

Gerando uma Chave Segura

Para gerar uma chave segura para produção, você pode usar:

    # Gere uma chave aleatória segura
    openssl rand -base64 64
    
    # Configure-a como variƔvel de ambiente
    export JWT_SECRET_KEY=$(openssl rand -base64 64)

Notas Importantes

  1. Prioridade de Configuração: A função GetJWTSecret() implementa uma ordem clara de prioridade: variÔvel de ambiente específica > configuração > valor padrão.

  2. Segurança em Produção: O valor padrão hardcoded deve ser usado apenas em desenvolvimento. Em produção, sempre configure um segredo único e seguro.

  3. Centralização: Esta abordagem centraliza a lógica de obtenção do segredo, tornando mais fÔcil rastrear e modificar no futuro.

  4. Logs e Avisos: Foram adicionados avisos claros quando o valor padrão inseguro estÔ sendo usado.

Ao fazer essas alterações, você estÔ removendo os valores hardcoded e implementando uma abordagem mais flexível e segura para gerenciar o segredo JWT.

Isto gerarÔ um token JWT vÔlido que você pode usar para autenticar requisições administrativas.

Autenticação via API

TambƩm Ʃ possƭvel obter um token via API apartir do usuƔrio admin criado anteriormente (se configurada):

    # Login para obter token JWT
    curl -X POST http://localhost:8080/auth/login \
      -H "Content-Type: application/json" \
      -d '{"username":"admin","password":"senha123"}'
Usando o Token nas RequisiƧƵes

Use o token obtido nos cabeƧalhos de suas requisiƧƵes:

    curl -X GET http://localhost:8080/admin/apis \
      -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

Gerenciando UsuƔrios

Obter Token de Admin

Primeiro, você precisa obter um token de autenticação:

    curl -X POST http://localhost:8080/auth/login \
      -H "Content-Type: application/json" \
      -d '{
        "username": "admin",
        "password": "sua-senha-admin"
      }'
1. Listar UsuƔrios
    curl -X GET http://localhost:8080/admin/users \
      -H "Authorization: Bearer seu-token-aqui"
2. Criar Novo UsuƔrio
    curl -X POST http://localhost:8080/admin/users \
      -H "Authorization: Bearer seu-token-aqui" \
      -H "Content-Type: application/json" \
      -d '{
        "username": "novouser",
        "password": "senha123",
        "email": "novouser@exemplo.com",
        "role": "user"
      }'
3. Obter UsuƔrio por ID
    curl -X GET http://localhost:8080/admin/users/id-do-usuario \
      -H "Authorization: Bearer seu-token-aqui"
4. Atualizar UsuƔrio
    curl -X PUT http://localhost:8080/admin/users/id-do-usuario \
      -H "Authorization: Bearer seu-token-aqui" \
      -H "Content-Type: application/json" \
      -d '{
        "username": "usernovo",
        "password": "novasenha123",
        "role": "editor"
      }'
5. Excluir UsuƔrio
    curl -X DELETE http://localhost:8080/admin/users/id-do-usuario \
      -H "Authorization: Bearer seu-token-aqui"

šŸ“ Uso da API

Gerenciamento de Rotas

O API Gateway atua como um proxy reverso, redirecionando requisições para serviços de backend conforme a configuração de rotas.

Cadastro de Rotas

Existem duas maneiras de cadastrar rotas:

  1. Via arquivo JSON (em config/routes.json ):
    [
      {
        "path": "/api/users",
        "serviceURL": "http://user-service:8000",
        "methods": ["GET", "POST", "PUT", "DELETE"],
        "headers": ["Content-Type", "Authorization"],
        "description": "ServiƧo de usuƔrios",
        "isActive": true,
        "requiredHeaders": ["X-Request-ID"]
      }
    ]
  1. Via API administrativa:
    # Registrar nova rota
    curl -X POST http://localhost:8080/admin/register \
      -H "Authorization: Bearer seu-token-aqui" \
      -H "Content-Type: application/json" \
      -d '{
        "path": "/api/products/",
        "serviceURL": "http://product-service:8001",
        "methods": ["GET", "POST"],
        "description": "ServiƧo de produtos",
        "isActive": true,
        "requiredHeaders": ["X-Request-ID"]
      }'
      
      OU
      
    # Registrar nova rota com parametros
    curl -X POST http://localhost:8080/admin/register \
      -H "Authorization: Bearer seu-token-aqui" \
      -H "Content-Type: application/json" \
      -d '{
        "path": "/api/products/:parametro",
        "serviceURL": "http://product-service:8001",
        "methods": ["GET"],
        "description": "ServiƧo de produtos",
        "isActive": true,
        "requiredHeaders": ["X-Request-ID"]
      }'
      
      OU
      
    # Registrar nova rota curinga
    curl -X POST http://localhost:8080/admin/register \
      -H "Authorization: Bearer seu-token-aqui" \
      -H "Content-Type: application/json" \
      -d '{
        "path": "/api/products/*",
        "serviceURL": "http://product-service:8001",
        "methods": ["GET", "PUT"],
        "description": "ServiƧo de produtos",
        "isActive": true,
        "requiredHeaders": ["X-Request-ID"]
      }'  
Listagem e Gerenciamento de Rotas
    # Listar todas as rotas cadastradas
    curl -X GET http://localhost:8080/admin/apis \
      -H "Authorization: Bearer seu-token-aqui"
    
    # Atualizar uma rota existente
    curl -X PUT http://localhost:8080/admin/update \
      -H "Authorization: Bearer seu-token-aqui" \
      -H "Content-Type: application/json" \
      -d '{
        "path": "/api/products",
        "serviceURL": "http://product-service:8002",
        "methods": ["GET", "POST", "PUT"],
        "description": "API de produtos atualizada",
        "isActive": true
      }'
    
    # Excluir uma rota
    curl -X DELETE http://localhost:8080/admin/delete?path=/api/products \
      -H "Authorization: Bearer seu-token-aqui"
    
    # Diagnosticar problemas em uma rota
    curl -X GET "http://localhost:8080/admin/diagnose-route?path=/api/products" \
      -H "Authorization: Bearer seu-token-aqui"
    
    # Limpar cache de rotas (quando houver alterações que não estão sendo refletidas)
    curl -X GET http://localhost:8080/admin/clear-cache \
      -H "Authorization: Bearer seu-token-aqui"
Estrutura de uma Rota
Campo             │ Descrição                           │ Obrigatório        
───────────────────┼─────────────────────────────────────┼────────────────────
path             │ Caminho da rota (ex:  /api/users )  │ Sim                
serviceURL       │ URL do serviƧo de backend           │ Sim                
methods          │ MĆ©todos HTTP permitidos (array)     │ Sim                
headers          │ CabeƧalhos a serem passados (array) │ NĆ£o                
description      │ Descrição da rota                   │ NĆ£o                
isActive         │ Se a rota estĆ” ativa                │ NĆ£o (padrĆ£o: true)
requiredHeaders  │ CabeƧalhos obrigatórios             │ NĆ£o

🚦 Rate Limiting e Proteção

Configuração Global

Configure rate limiting global no arquivo de configuração:

    features:
      ratelimiter: true
    
    ratelimit:
      defaultLimit: 100         # RequisiƧƵes por minuto por IP
      burstFactor: 1.5          # Fator de rajada
      type: "redis"             # "memory" ou "redis" 
      redisAddress: "redis:6379"
Configuração por Rota

Cada rota pode ter seus próprios limites configurados durante o registro:

    curl -X POST http://localhost:8080/admin/register \
      -H "Authorization: Bearer seu-token-aqui" \
      -H "Content-Type: application/json" \
      -d '{
        "path": "/api/sensitive",
        "serviceURL": "http://sensitive-service:8000",
        "methods": ["GET"],
        "description": "API com acesso limitado",
        "isActive": true,
        "rateLimit": {
          "requestsPerMinute": 30,
          "burstFactor": 1.2
        }
      }'
Comportamento em Excesso de RequisiƧƵes

Quando o limite Ć© excedido, o API Gateway retorna:

  • Status HTTP 429 (Too Many Requests)
  • CabeƧalho Retry-After com o tempo de espera em segundos
  • Corpo JSON com mensagem de erro e tempo de espera

šŸ”„ Circuit Breaking

O Circuit Breaker protege os serviços de backend contra sobrecarga quando estão falhando.

Como Funciona
  1. Em condiƧƵes normais, as requisiƧƵes passam normalmente (circuito fechado)
  2. Quando um serviƧo falha consistentemente, o circuito abre temporariamente
  3. Durante este perƭodo, as requisiƧƵes falham rapidamente sem tentar acessar o serviƧo
  4. Após um tempo, o circuito entra em estado semiaberto, permitindo algumas requisições de teste
  5. Se essas requisiƧƵes de teste forem bem-sucedidas, o circuito fecha novamente
Configuração
    circuitbreaker:
      enabled: true
      timeout: "30s"          # Tempo de abertura do circuito
      maxRequests: 5          # RequisiƧƵes permitidas no estado semiaberto
      interval: "1m"          # Intervalo para anƔlise de falhas
      failureThreshold: 0.5   # Percentual de falhas para abrir o circuito (50%)

šŸ“Š Monitoramento e MĆ©tricas

MƩtricas do Prometheus

O API Gateway expƵe mƩtricas no formato Prometheus no endpoint /metrics :

    # Acessar mƩtricas do Prometheus
    curl -X GET http://localhost:8080/metrics

Ou visualize o dashboard no Grafana em http://localhost:3000 (usuÔrio: admin, senha: admin por padrão).

Principais MƩtricas Disponƭveis
  • api_gateway_requests_total : Total de requisiƧƵes por rota, mĆ©todo e código de status
  • api_gateway_request_duration_seconds : Duração das requisiƧƵes em segundos
  • api_gateway_active_requests : NĆŗmero de requisiƧƵes em andamento
  • api_gateway_errors_total : Total de erros por tipo
  • api_gateway_circuit_breaker_open : Estado dos circuit breakers (1=aberto, 0=fechado)
  • api_gateway_rate_limited_requests_total : RequisiƧƵes limitadas por rate limiting
  • api_gateway_cache_hit_ratio : Taxa de acerto de cache
Visualização com Grafana

O Docker Compose inclui Grafana prƩ-configurado com dashboard para as mƩtricas do API Gateway:

  1. Acesse http://localhost:3000
  2. Faça login (usuÔrio: admin, senha: admin por padrão)
  3. Navegue atƩ o dashboard "API Gateway Overview"

šŸ” Health Check e Diagnóstico

O API Gateway oferece endpoints de health check para monitoramento:

    # Verificação bÔsica (liveness)
    curl -X GET http://localhost:8080/health
    
    # Verificação de prontidão (readiness)
    curl -X GET http://localhost:8080/health/readiness
    
    # Verificação detalhada de saúde (requer autenticação admin)
    curl -X GET http://localhost:8080/admin/health/detailed \
      -H "Authorization: Bearer seu-token-aqui"
Diagnosticando Problemas

Para problemas em rotas específicas, use o endpoint de diagnóstico:

    curl -X GET "http://localhost:8080/admin/diagnose-route?path=/api/problematico" \
      -H "Authorization: Bearer seu-token-aqui"

Este endpoint verifica:

  • Se a rota existe no banco de dados
  • Se a rota estĆ” ativa
  • Se a URL do serviƧo Ć© vĆ”lida
  • Se o serviƧo de destino estĆ” acessĆ­vel
  • LatĆŖncia aproximada do serviƧo

šŸ“¦ Cache

O API Gateway oferece cache de resposta para melhorar a performance.

Configuração Global
    cache:
      enabled: true
      type: "redis"            # "memory" ou "redis"
      address: "redis:6379"    # EndereƧo do Redis, se aplicƔvel
      ttl: "5m"                # Tempo de vida padrão
Configuração por Rota

Cada rota pode ter suas próprias configurações de cache:

    curl -X POST http://localhost:8080/admin/register \
      -H "Authorization: Bearer seu-token-aqui" \
      -H "Content-Type: application/json" \
      -d '{
        "path": "/api/products",
        "serviceURL": "http://product-service:8000",
        "methods": ["GET"],
        "description": "ServiƧo de produtos",
        "isActive": true,
        "cache": {
          "enabled": true,
          "ttl": "10m"
        }
      }'
Invalidação de Cache

Para invalidar o cache manualmente:

    # Limpar cache de todas as rotas
    curl -X GET http://localhost:8080/admin/clear-cache \
      -H "Authorization: Bearer seu-token-aqui"
    
    # Limpar cache de uma rota especĆ­fica
    curl -X POST http://localhost:8080/admin/clear-route-cache \
      -H "Authorization: Bearer seu-token-aqui" \
      -H "Content-Type: application/json" \
      -d '{"path": "/api/products"}'
Diagnóstico de UsuÔrio

Para PostgreSQL

go run cmd/tools/diagnose_user.go -username "admin" -driver postgres -dsn "postgres://postgres:postgres@localhost:5432/apigateway?sslmode=disable"

Para SQLite

go run cmd/tools/diagnose_user.go -username "admin" -driver sqlite -dsn "./data/apigateway.db"

Esta ferramenta é especialmente útil para diagnosticar problemas específicos com o armazenamento de usuÔrios em diferentes tipos de banco de dados, permitindo comparar diretamente como os dados são armazenados e ajudando a identificar incompatibilidades.

šŸ”’ SeguranƧa AvanƧada

Proteção Contra Ataques Comuns

O API Gateway implementa automaticamente vƔrias proteƧƵes:

  1. Proteção CSRF: Para rotas que exigem
  2. Proteção XSS: Cabeçalhos X-XSS-Protection e Content-Security-Policy
  3. Proteção contra Clickjacking: Cabeçalho X-Frame-Options
  4. Proteção CORS: Controle detalhado de Cross-Origin Resource Sharing
  5. Validação de Entrada: Filtragem de dados maliciosos
CabeƧalhos de SeguranƧa

Por padrão, o API Gateway adiciona cabeçalhos de segurança a todas as respostas:

X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
Content-Security-Policy: default-src 'self'
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
Referrer-Policy: strict-origin-when-cross-origin

šŸš€ Implantação em Produção

Checklist de Produção

Para implantação segura em produção, verifique:

[ ] Configurar chave JWT forte e armazenada com seguranƧa [ ] Ativar HTTPS (TLS) com certificados vƔlidos [ ] Configurar limites de rate limiting apropriados [ ] Configurar banco de dados com backup automƔtico [ ] Ativar monitoramento e alertas [ ] Implementar logging centralizado [ ] Revisar todas as configuraƧƵes de seguranƧa

šŸ”„ AtualizaƧƵes e MigraƧƵes

Atualizando o API Gateway
# Atualizar o código-fonte
git pull

# Executar migraƧƵes de banco de dados
go run cmd/migrate/main.go

# Reconstruir e reiniciar o serviƧo
docker-compose build api-gateway
docker-compose up -d api-gateway
MigraƧƵes de Banco de Dados
    # Criar nova migração
    go run cmd/migrate/main.go -action create -name add_new_field
    
    # Aplicar migraƧƵes pendentes
    go run cmd/migrate/main.go -action migrate
    
    # Reverter última migração (rollback)
    go run cmd/migrate/main.go -action rollback

šŸ“š Arquitetura

O API Gateway foi construĆ­do seguindo os princĆ­pios de Clean Architecture:

  • cmd/: Ponto de entrada da aplicação, definiƧƵes de CLI
  • internal/: Código especĆ­fico da aplicação nĆ£o reusĆ”vel
  • adapter/: ImplementaƧƵes concretas de interfaces
  • app/: Casos de uso da aplicação
  • domain/: Entidades de domĆ­nio e regras de negócio
  • infra/: Infraestrutura como middleware e logging
  • pkg/: Biblioteca reutilizĆ”vel que pode ser importada por outros projetos
  • config/: Arquivos de configuração
  • migrations/: MigraƧƵes de banco de dados
  • tests/: Testes de integração e carga

šŸ¤ Contribuição

Contribuições são bem-vindas! Por favor, leia o CONTRIBUTING.md para detalhes sobre nosso código de conduta e processo de envio de Pull Requests.

šŸ“„ LicenƧa

Este projeto estƔ licenciado sob a licenƧa MIT - veja o arquivo LICENSE para detalhes.

ā“ Resolução de Problemas Comuns

Token JWT InvƔlido ou Expirado

Se vocĆŖ encontrar erros com tokens JWT:

  1. Verifique se o token foi gerado corretamente com go run cmd/tools/generate_token.go
  2. Certifique-se de que o segredo JWT é o mesmo no arquivo de configuração e no token
  3. Verifique se o token não estÔ expirado (duração padrão: 24h)
  4. Limpe o cache do navegador caso esteja usando uma interface web
Rotas NĆ£o Encontradas

Se suas rotas registradas não estão funcionando:

  1. Verifique se a rota estĆ” registrada corretamente com curl -X GET http://localhost:8080/admin/apis
  2. Limpe o cache de rotas: curl -X GET http://localhost:8080/admin/clear-cache
  3. Verifique se o serviƧo de destino estƔ acessƭvel com curl -X GET "http://localhost:8080/admin/diagnose-route?path=/sua/rota"
  4. Verifique se o formato da rota estÔ correto (deve começar com /api/ ou /ws/ por padrão)
Problemas de Banco de Dados

Para problemas relacionados ao banco de dados:

  1. Verifique as configurações de conexão no arquivo config.yaml
  2. Execute go run cmd/migrate/main.go para aplicar migraƧƵes pendentes
  3. Verifique se o banco de dados estĆ” acessĆ­vel com a ferramenta adequada (psql, mysql, sqlite3)
Segurança e Autenticação

Para problemas de autenticação:

  1. Use a ferramenta de linha de comando para gerar um novo token administrativo
  2. Verifique os logs para mensagens detalhadas de erro
  3. Se você esqueceu a senha do administrador, crie um novo usuÔrio admin usando a ferramenta CLI

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL