Categoria: tutoriais

gonew: Como criar projetos a partir de templates

Tiago TemporinDeixe um comentário

Ouvindo aos pedidos da comunidade, mesmo que não incorporado oficialmente ao CLI do Go ainda, o time de desenvolvimento da linguagem Go criou um novo programa capaz de ajudar a iniciar novos projetos. Seu nome, pelo menos por enquanto, gonew.

Como dito no parágrafo anterior, a finalidade desse novo programa é auxiliar na criação de novos projetos Go. Com ele, podemos utilizar um repositório template como base para novas aplicações.

Sem mais delongas, vamos meter a mão na massa, ou melhor, no teclado.

Instalação

Para conseguir utilizar esse novo programa, precisamos tê-lo instalado. A forma mais fácil, já que você muito provavelmente tem o Go instalado na sua máquina, é utilizar o comando go install.

go install golang.org/x/tools/cmd/gonew@latest
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 utilizar o princípio de Open-Closed

Tiago TemporinDeixe um comentário

Nesse penúltimo post sobre SOLID, vamos falar sobre a letra “O”, ou seja, o princípio Open-Closed. Antes de começar, caso você esteja chegando no blog agora, vou deixar aqui os links para os posts anteriores da série.

Voltando para o assunto desse post, vamos relembrar o que o princípio Open-Closed nos diz.

💡 Uma classe deve estar aberta para extensões, mas fechada para modificações. Ou seja, sempre que for necessário adicionar funcionalidades, devemos estender a classe ao invés de modificá-la.

Ao ler “…estender a classe…” na definição do princípio, provavelmente você pensou. “Vixi, não dá para aplicar em Go”, ou, “Fácil, só usar embedding nas structs”.

Leia mais »

Aplicando Liskov Substitution Principle

Tiago TemporinDeixe um comentário

Dando início ao quarto post da série sobre SOLID, vamos falar um pouco sobre Liskov Substitution Principle.

Se você ainda não leu os outro posts da série, vou deixar os links aqui para que o faça.

Liskov Substitution, dos cinco princípios do SOLID, talvez seja o mais simples para se aplicar. Vamos relembrar o que diz esse princípio.

Classes “filhas” podem ser utilizadas no lugar das classes “pais” sem que o programa quebre. Em outras palavras, uma classe filha, mesmo com suas especificidades, deve manter o mesmo comportamento da classe pai.

Aqui, antes de continuar, vale fazer duas observações.

  1. Não existe orientação a objetos em Go, logo não temos classes.
  2. Como não temos classes, não temos herança.

Nesse momento você deve estar se perguntando. Se não temos classes e nem herança, como podemos aplicar esse princípio no Go?

Simples! Onde o princípio diz classe, pense em structs. Já onde diz herança, pense na técnica de embedding.

Ok! Agora que estamos alinhados, voltemos ao princípio.

Leia mais »

O que é e como Interface Segregation é aplicada no Go

Tiago TemporinDeixe um comentário

Dando continuidade na série sobre SOLID, nesse post vamos falar um pouco sobre Interface Segregation. Esse princípio talvez seja o mais utilizado na linguagem. Digo isso pois ele é fortemente utilizado nos packages core do Go, como por exemplo o package io.

Antes de continuar, se você chegou por aqui agora e ainda não viu os outros posts da série, convido-o a dar uma olhada.

Voltando à esse post, vamos relembrar o que diz o conceito de Interface Segregation.

💡 Uma classe não deve ser obrigada a implementar interfaces e métodos que não utilizará. Em outras palavras, é melhor ter 6 interfaces bem específicas, do que 2 mais genéricas.

Embora Go não implemente orientação a objetos, Interface Segregation pode ser aplicado na linguagem sem problemas. Isso devido a forma como structs e interfaces funcionam na linguagem.

Leia mais »

O que é e como aplicar Dependency Inversion Principle

Tiago Temporin2 Comentários

Nesse segundo post da série de posts sobre SOLID em Go, foquemos na letra ‘D’, ou seja, no Dependency Inversion Principle.

Se você não viu o primeiro post da série, recomendo a leitura para ter uma visão geral do que é SOLID.

Antes de ver como aplicar Dependency Inversion Principle em Go, vamos relembrar seu conceito.

Dependências devem ser abstraídas, para que os módulos de alto nível não dependam dos módulos de baixo nível.

Para facilitar o entendimento, vejamos um pouco de código. Para começar, um exemplo de como violar o Dependency Inversion Principle.

Leia mais »
top view photo of vehicles driving on road

Como publicar packages em domínios próprios

Tiago TemporinDeixe um comentário

Se você já trabalha com Go, muito provavelmente já utilizou algum package com vanity import path (domínio próprio). Packages com domínio próprio são aqueles que não iniciam, por exemplo, com github.com. Alguns exemplos de package que utilizam vanity import path são go.uber.org/zap, gorm.io/gorm e cloud.google.com/go/pubsub.

Por trás dessas URLs personalizadas, o package continua sendo hospedado em sites como GitHub, Bitbucket ou algum VCS (version control system) próprio. No entanto, para utilizá-lo, ao invés de utilizar o endereço do repositório, utilizamos um domínio customizado.

Além do package passar mais confiança, dar mais visibilidade para sua empresa e etc… utilizar essa estratégia ajuda em casos de migração. Isso por que o endereço do import permanecerá o mesmo, mudando somente o endereço do repositório.

Sem mais delongas, vamos ver o que precisamos fazer para ter um package com domínio próprio.

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 »
photo of a turtle swimming underwater

O que é e como utilizar o tipo enum

Tiago Temporin1 comentário

Muitas vezes, dentro dos sistemas que desenvolvemos, temos valores constantes. Dentre outras possibilidades, um exemplo desses valores, seria a representação do status de um cadastro. Nesse caso, pense em um status onde temos variações além de ativo e inativo.

Caso esses status sejam definidos como string, sua validação dentro do sistema pode acabar se tornando uma grande dor de cabeça. Além, é claro, de “inflar” o binário. Afinal, em cada validação teremos 2 strings (valor esperado e valor sendo validado).

Na tentativa de evitar esses problemas, podemos utilizar o famoso tipo enum. Se você não está familiarizado com esse tipo, ele nada mais é do que um tipo de tamanho limitado ou fixo.

Para ficar mais claro, vamos escrever um pouco de código. Seguindo a ideia apresentada no inicio do post, vamos criar um tipo enum para validar status de um cadastro.

Leia mais »
rock formation

Como utilizar “herança” em interfaces

Tiago TemporinDeixe um comentário

Embora o Golang não implemente orientação a objetos, de forma superficial, sua estratégia de embedding – que inclusive é muito utilizada nos packages nativos da linguagem – é muito parecida com a famosa herança.

Nesse post, vou mostrar como utilizar essa estratégia para que possamos ter interfaces mais granulares.

Antes de começar, como o objetivo desse post é exemplificar como utilizar embedding em interfaces, não vamos implementar os métodos. Também não vamos mostrar como utilizá-las em assinaturas de funções/métodos. Caso você queria saber mais sobre como utilizar interfaces, recomendo a leitura do post “Trabalhando com Interfaces”.

Sem mais delongas, vamos criar 3 interfaces. Writer, Reader e Closer.

type Writer interface {
	Write(p []byte) (n int, err error)
}

type Reader interface {
	Read(p []byte) (n int, err error)
}

type Closer interface {
	Close() error
}
Leia mais »