https://github.com/apozzi/go-kong-microservices-role-boilerplate
Tecnologias. Golang + Gin/Gorm (Microserviços) + Kong (Api Gateway) + Konga + JWT (Autenticação) + Swagger
https://github.com/apozzi/go-kong-microservices-role-boilerplate
go kong kong-api-gateway konga
Last synced: 3 months ago
JSON representation
Tecnologias. Golang + Gin/Gorm (Microserviços) + Kong (Api Gateway) + Konga + JWT (Autenticação) + Swagger
- Host: GitHub
- URL: https://github.com/apozzi/go-kong-microservices-role-boilerplate
- Owner: Apozzi
- Created: 2025-01-16T19:11:32.000Z (5 months ago)
- Default Branch: main
- Last Pushed: 2025-01-16T19:38:34.000Z (5 months ago)
- Last Synced: 2025-01-16T20:32:49.638Z (5 months ago)
- Topics: go, kong, kong-api-gateway, konga
- Language: Go
- Homepage:
- Size: 63.5 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Login Role Microservices Backend
[](https://golang.org)
[](https://konghq.com)
[](https://github.com/pantsel/konga)
[](https://jwt.io)
[](https://rabbitmq.com)
[](https://microservices.io)
[](https://konghq.com/learning-center/api-gateway/)
Microserviços feitos em golang utilizando frameworks Gin e o a ORM do Gorm e Kong como Api Gateway, e com RabbitMQ.
Os serviços tem modelos de usuário e permissões por papeis.
## Arquitetura
## Como rodar? (Windows)
O backend roda utilizando Go 1.17, é importante que tenha Postgres instalado e rodando na maquina.
Primeiramente devemos ter broker executando na nossa maquina, com docker instalado, podemos rodar através do comando docker.:
`docker run -it --rm --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:4.0-management`
Com isso verificamos se rabbitMQ está rodando e se quisermos podemos acessar `http://localhost:15672/#/` (User:guest, senha:guest)
Após isso necessária instalação das dependencias na pasta de cada projeto, vale lembrar que temos 4 pastas com microserviços diferentes.
`item-microservice`
`role-microservice`
`user-microservice`
`email-microservice`
Rodar o seguinte comandos em todos os projetos.
```
go install
```
Após isso basta utilizar seguinte comando para rodar o backend em cada pasta de cada microserviço:
```
go run cmd/main.go
```
Com isso teremos os seguintes microserviços rodando nas seguintes portas.
`item-microservice` = `localhost:8083`
`role-microservice` = `localhost:8082`
`user-microservice` = `localhost:8081`
O `email-microservice` não roda nenhuma porta e só serve para se comunicar com outros serviços através do rabbitMQ.
Ao rodar cada microserviço ele fará migrate na base criando todas as tabelas no Postgres, também é possivel fazer criação de tabela e registros através da pasta `database`.
## Usando Kong e Konga, como Api Gateway.
Dentro das pasta `docker-kong` criar imagem docker com commando ```docker network create kong-net```, execute os seguintes comandos respectivamente:
- ```docker-compose up -d db``` esperar iniciar o banco.
- ```docker-compose ps```
- ```docker-compose up -d ```
Após isso acessar `localhost:1337` aonde fica o Konga e criar usuario e senha (a que eu usei foram username:admin, password:ADMINADMIN).
Depois disso é só criar seguinte conexão com o Kong.
Na aba serviços criar cada respectivo serviço `rolemanager`, `itemmanager`, `usermanager`, da seguinte forma (vale lembrar que no host utilizaremos ip da nossa maquina local).
E após isso vamos e `routes` e criamos uma rota também para cada serviço.
Com isso nossos serviços estarão todos rodando através da mesma porta no `localhost:8000` nas rotas `http://localhost:8000/usermanager`, `http://localhost:8000/itemmanager`, `http://localhost:8000/rolemanager`, e
podemos acessar swagger de cada um respectivamente: http://localhost:8000/usermanager/swagger/index.html#/ (é possivel editar as rotas no swagger para aparecer da forma correta após config do Kong)