Tag: api

Arquitetura hexagonal: Como implementar ports

Tiago TemporinDeixe um comentário

Dando continuidade à série de posts sobre arquitetura hexagonal, nesse post implementaremos os ports do package category.

Se você está chegando agora ou se gostaria de relembrar, até o momento nós já:

Ports para atores Driven

Como é através de ports que o core da aplicação se comunicará com o mundo externo e, os atores do tipo driven são chamados a partir do core, a primeira coisa que vamos fazer é definir uma interface para esse tipo de ator.

type Repository interface {
	FindAll() ([]*Category, error)
	FindById(id string) (*Category, error)
	Save(category *Category) error
	Delete(id string) error
}
Leia mais »

Arquitetura hexagonal: Como implementar uma entity

Tiago TemporinDeixe um comentário

Dando continuidade à nossa série de posts sobre arquitetura hexagonal, nesse post implementaremos a entity do package category, que faz parte do core da aplicação.

Se você ainda não leu, convido a ler o post onde definimos a organização das pastas e arquivos desse projeto utilizando arquitetura hexagonal.

Definindo Category

Sem mais delongas, a primeira coisa que vou fazer no arquivo entity.go, é definir a struct Category.

type Category struct {
	ID          primitive.ObjectID `bson:"_id" json:"id"`
	Name        string             `bson:"name" json:"name"`
	Description string             `bson:"description" json:"description"`
	CreatedAt   time.Time          `bson:"created_at" json:"created_at"`
	ModifiedAt  time.Time          `bson:"modified_at" json:"modified_at"`
	Active      bool               `bson:"active" json:"active"`
}
Leia mais »

Como implementar uma API com arquitetura hexagonal

Tiago Temporin8 Comentários

Hoje iniciamos mais uma pequena série aqui no blog, onde vamos implementar uma pequena API utilizando arquitetura hexagonal. Essa série será dividida em pelo menos quatro posts, sendo esse primeiro a definição da estrutura de pastas.

Se você ainda não conhece muito bem essa arquitetura, convido você a ler o post onde explico a parte teórica da arquitetura hexagonal.

Agora que estamos todos no mesmo ponto, vamos começar a definir a estrutura de pastas desse pequeno projeto.

pkg

No root do projeto, como já é de costume, precisamos de uma pasta onde ficarão as implementações que podem ser compartilhadas com outros projetos, ou seja, implementações de packages que não tem nenhuma regra de negócio.

Leia mais »

Implementando comunicação com API gRPC

Tiago TemporinDeixe um comentário

Dando continuidade na implementação de serviços utilizando gRPC, nesse post vamos implementar o lado cliente da comunicação.

Se você ainda não leu o post anterior, onde implementamos a API em gRPC, peço que leia, pois os passos para definição do arquivo proto e geração do código utilizando protoc, foram feitos lá e não precisam ser repetidos.

Conexão com API

Vamos iniciar a implementação do client.go definindo as credenciais de conexão.

creds := grpc.WithTransportCredentials(insecure.NewCredentials())
Leia mais »

Implementando uma API com protobuf e gRPC

Tiago Temporin1 comentário

Dando continuidade ao post o que é e como utilizar protobufs, nesse post, vamos colocar o conhecimento teórico em prática e fazer uma API utilizando protobuf e gRPC. Embora seja uma API simples, ela te dará uma ótima base para construir aplicações mais complexas.

Dependências

Mas antes de meter a mão na massa, precisamos instalar o protoc e os pluginsprotoc-gen-go e protoc-gen-go-grpc. Para instalar o protoc, independente do OS que você esteja utilizando, recomendo fazer download do binário direto da página de releases do projeto. Após o download, descompacte e mova o programa protoc, que está dentro da pasta bin, em alguma pasta que esteja referenciada ao seu $PATH, por exemplo, a pasta go/bin ou ~/.local/bin. Com o protoc instalado, agora precisamos instalar os dois plugins para gerar código Go. Partindo do princípio que você tem o Go instalado na sua máquina, execute os dois comandos abaixo para instalar os plugins.

$ go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.28
$ go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.2
Leia mais »

Como fazer graceful shutdown correto em um server HTTP

Tiago Temporin1 comentário

Embora esse tema não seja abordado em exemplos simples de APIs, ele é muito importante. Encerrar um servidor HTTP de forma abrupta, acaba por fechar todas as conexões que ele tem abertas da mesma forma. Em outras palavras, não tratar desligamentos via SIGINT ou SIGTERM de uma API, pode acabar gerando grandes problemas.

Para evitar tais problemas, vou mostrar nesse post como tratar tais sinais e fazer um graceful shutdown do seu servidor HTTP.

Servidor HTTP

Para começar, vamos escrever uma rota que retornará um “hello world”. Vou utilizar o package go-chi para definir a rota não por ser necessário, mas para facilitar o entendimento em aplicações do mundo real.

r := chi.NewRouter()

r.Get("/", func(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Hello World"))
})
Leia mais »

Como utilizar go-chi para rotas e middleware

Tiago TemporinDeixe um comentário

Durante muito tempo, gorilla/mux era o meu router favorito na hora de escrever APIs. Porém, desde que fiz o post sobre benchmark comparando gorilla/mux e go-chi (link para o post), meu router favorito tem sido o go-chi, pois sua performance é bem superior. E para ajudar, recentemente o projeto do gorilla/mux ficou sem mantenedor. ☹️

Por isso, resolvi fazer esse post para mostrar tudo o que você pode fazer com go-chi.

Para começar, vamos escrever um código muito simples para criar uma rota com o verbo GET.

Leia mais »

Benchmark dos routers http: chi vs gorilla mux

Tiago Temporin1 comentário

Até pouco tempo atrás eu nunca tinha ouvido falar sobre o go-chi. Foi durante uma reunião de trabalho que o Marcos Filho comentou sobre. Na mesma hora eu já anotei aqui na lista de idéias de posts para o blog para fazer uma comparação entre ele e o gorilla/mux.

Meus testes foram basicamente escrever um simples server http com a rota /{name}. Nesse server utilizei a ferramenta wrk para um teste de carga. Também escrevi um benchmark da própria linguagem para verificar, além de quanta porrada ele aguenta, o quanto de recurso os routers consumem.

Para fica mais simples, vou separar as comparações em três partes, onde nas duas primeiras vou apresentar os resultados individuais e por fim uma conclusão.

Então, para começar, vamos ver os resultados do router mais famoso do mundo Go.

Leia mais »

Implementando uma API com Fiber

Tiago TemporinDeixe um comentário

Embora eu não tenha dito no post anterior, semana passada iniciamos uma nova série aqui no blog onde vamos implementar uma API bem simples em alguns frameworks web.

Dando continuidade a essa série, hoje vamos implementar uma API utilizando o Fiber, um framework inspirado no Express do Node e que trabalha com Fasthttp ao invés do net/http.

Como podemos ver no gráfico abaixo, uma de suas características mais marcantes é a performance.

Leia mais »

Implementando uma API com gorilla/mux

Tiago Temporin1 comentário

Sem dúvidas um dos routers mais famosos e utilizados no mundo Golang, hoje vamos ver como implementar uma API utilizando gorilla/mux.

Para quem não conhecer, gorilla/mux ajuda na hora de fazer o match da URL que está sendo chamada com a função que vai tratar aquela URL. Além dessa facilidade, um dos principais benefícios de se utilizar gorilla/mux é que ele implementa a interface http.Handler nativa do Go.

Sem mais delongas, vamos começar implementar nossa API instalando o gorilla/mux.

$ go get -u github.com/gorilla/mux
Leia mais »