README
¶
API Gateway em Go
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:
- Arquivo de configuração YAML
- VariƔveis de ambiente (prefixo AG_ )
- 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):
- Via variƔvel de ambiente:
export JWT_SECRET_KEY=sua-chave-secreta-muito-longa-e-aleatoria
- Via variƔvel de ambiente com prefixo AG:
export AG_AUTH_JWT_SECRET_KEY=sua-chave-secreta-muito-longa-e-aleatoria
- 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
-
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. -
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.
-
Centralização: Esta abordagem centraliza a lógica de obtenção do segredo, tornando mais fÔcil rastrear e modificar no futuro.
-
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:
- 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"]
}
]
- 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
- Em condiƧƵes normais, as requisiƧƵes passam normalmente (circuito fechado)
- Quando um serviƧo falha consistentemente, o circuito abre temporariamente
- Durante este perĆodo, as requisiƧƵes falham rapidamente sem tentar acessar o serviƧo
- Após um tempo, o circuito entra em estado semiaberto, permitindo algumas requisições de teste
- 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:
- Acesse http://localhost:3000
- Faça login (usuÔrio: admin, senha: admin por padrão)
- 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:
- Proteção CSRF: Para rotas que exigem
- Proteção XSS: Cabeçalhos X-XSS-Protection e Content-Security-Policy
- Proteção contra Clickjacking: Cabeçalho X-Frame-Options
- Proteção CORS: Controle detalhado de Cross-Origin Resource Sharing
- 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:
- Verifique se o token foi gerado corretamente com go run cmd/tools/generate_token.go
- Certifique-se de que o segredo JWT é o mesmo no arquivo de configuração e no token
- Verifique se o token não estÔ expirado (duração padrão: 24h)
- Limpe o cache do navegador caso esteja usando uma interface web
Rotas NĆ£o Encontradas
Se suas rotas registradas não estão funcionando:
- Verifique se a rota estĆ” registrada corretamente com curl -X GET http://localhost:8080/admin/apis
- Limpe o cache de rotas: curl -X GET http://localhost:8080/admin/clear-cache
- Verifique se o serviƧo de destino estĆ” acessĆvel com curl -X GET "http://localhost:8080/admin/diagnose-route?path=/sua/rota"
- 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:
- Verifique as configurações de conexão no arquivo config.yaml
- Execute go run cmd/migrate/main.go para aplicar migraƧƵes pendentes
- 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:
- Use a ferramenta de linha de comando para gerar um novo token administrativo
- Verifique os logs para mensagens detalhadas de erro
- Se você esqueceu a senha do administrador, crie um novo usuÔrio admin usando a ferramenta CLI
Directories
¶
Path | Synopsis |
---|---|
cmd
|
|
apigateway
command
|
|
genconfig
command
|
|
migrate
command
|
|
tools
command
|
|
internal
|
|
pkg
|
|