Categoria: api

Estratégias para gerenciar múltiplas versões de APIs

Tiago Temporin1 comentário

No universo do desenvolvimento de software, as APIs (Application Programming Interfaces) desempenham um papel fundamental na comunicação entre diferentes sistemas. No entanto, à medida que uma API evolui, surge um desafio inevitável: como gerenciar múltiplas versões sem comprometer a experiência dos usuários e sem introduzir instabilidade no sistema?

Neste post, exploraremos as principais estratégias para gerir e versionar APIs de forma eficaz. Vamos discutir diferentes abordagens, suas vantagens e desvantagens, além de apresentar ferramentas que podem facilitar o processo.

Versionamento por URL

O versionamento por URL é uma das abordagens mais comuns e simples. Nesta estratégia, a versão da API é incluída diretamente na URL, como por exemplo:

<https://api.exemplo.com/v1/recursos>
<https://api.exemplo.com/v2/recursos>
Leia mais »

Integrando aplicações Go com ChatGPT

Tiago TemporinDeixe um comentário

Com o avanço das tecnologias de inteligência artificial, cada vez mais desenvolvedores buscam integrar suas aplicações com APIs de IA para oferecer funcionalidades avançadas e personalizadas.

Uma dessas APIs é a do ChatGPT, desenvolvida pela OpenAI, que permite gerar texto de forma natural e coerente. Neste post, vou mostrar como você pode integrar uma aplicação Go com a API do ChatGPT para criar uma funcionalidade onde o usuário insere um valor monetário e a aplicação retorna esse valor por extenso.

Pré-requisitos para a Integração

Antes de iniciar a integração, é necessário cumprir alguns pré-requisitos:

  1. Conta na OpenAI: Você precisará de uma conta na OpenAI para acessar a API do ChatGPT.
  2. API Key: Após criar sua conta, você deve gerar uma chave de API (API Key) no painel de controle da OpenAI.
Leia mais »

Como implementar mTLS em aplicações Go

Tiago TemporinDeixe um comentário

Hoje vamos explorar como implementar o mTLS (Mutual TLS), que é uma técnica de segurança para autenticação mútua entre cliente e servidor, em uma aplicação Go.

Mas antes de começar, vamos entender um pouco melhor o que é TLS (Transport Layer Security) e qual sua diferença com mTLS.

TLS vs mTLS

O TLS é usado para criptografar a comunicação entre cliente e servidor. Nele, comumente usado em conexões HTTPS, apenas o servidor se autentica perante o cliente, usando um certificado digital para garantir que o cliente está se comunicando com o servidor correto.

Leia mais »

Arquitetura hexagonal: Como implementar uma entity

Tiago Temporin1 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 »

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 »
squirrel eating cone in forest

Como fazer fuzz test em requests HTTP (parte 1)

Tiago TemporinDeixe um comentário

Na edição de 2022 da GopherCon Brasil, tive o prazer de palestrar sobre Fuzz Test. Foi muito bacana, pois durante a palestra, assim como nos corredores do evento, fizeram vários questionamentos que eu ainda não tinha feito sobre essa feature do Go.

Se você ainda não conhece esse tipo de teste, convido você a ler um post que publicamos aqui no blog (link para o post) onde explicamos melhor o assunto.

O que vou tratar nesse post é o resultado das perguntas feitas no evento mais um link que o Ricardo Maricato me enviou.

Para ver uma das formas de implementar o Fuzz Test para requests HTTP, vamos implementar um endpoint para validação dos dados de uma pessoa.

Vamos começar criando uma struct com um método de validação, e algumas variáveis para armazenar os erros de validação que podemos ter.

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 »

Testando API’s feitas com gorilla/mux

Tiago TemporinDeixe um comentário

Algumas semanas atrás implementamos uma API utilizando gorilla/mux (link do post). No entanto, deixamos de lado algo que é muito importante, os famosos testes. Por isso, nesse post vamos corrigir essa falha e adicionar alguns testes ao nosso projeto.

Para começar, vamos criar um arquivo com o nome de hello_test.go dentro da pasta handlers. Nesse arquivo vamos adicionar um teste para a função HandleHello.

func TestHandleHello(t *testing.T) {
}

Com a função de testes iniciada, a primeira coisa que vamos fazer é criar uma struct anônima para nos auxiliar com uma massa de dados para teste. Dessa forma conseguiremos testar o mesmo endpoint com vários inputs diferentes.

Leia mais »