# Criação de gráficos com go-echarts

Sempre que pensamos em geração de gráficos a primeira solução que vem a cabeça é o Python e sua infinidade de bibliotecas, procurando algumas opções a isso encontrei várias soluções escritas em Go. Temos vários pacotes, alguns abandonados, outros arquivados e os dois que parecem se destacar são: go-echarts e Gonum Plot. Gostei da abordagem do go-echarts e resolvi seguir com ele. Essa lib é um wrapper da biblioteca JavaScript Apache ECharts. Para instalar, podemos criar um projeto e executar:

# Biblioteca lo

Dando uma explorada no ecossistema de bibliotecas do golang, e encontrei a lo. Ela traz para o Go uma série de funções inspiradas na programação funcional — como Map, Filter, Reduce, GroupBy e FlatMap. Vamos instalar a lib e fazer alguns testes:

go get github.com/samber/lo

Na programação funcional, map é uma função que aplica uma determinada função a cada elemento de uma coleção, no nosso caso aqui um slice, e retorna uma nova coleção contendo os resultados. Aqui vamos fazer o quadrado de cada elemento do slice.

# Reflect

Go é uma linguagem fortemente tipada, mas em alguns tipos de aplicações temos que trabalhar com tipos dinâmicos, exemplo disso é quando usamos um serializador ou ferramentas que inspecionam e manipulam structs no runtime. Para esses casos, a linguagem oferece o pacote reflect. O pacote reflect fornece reflexão de tempo de execução: a capacidade de inspecionar tipos, valores, e até modificar dados dinamicamente. Ele permite:

1. Verificar o tipo de um valor genérico
2. Obter campos e tags de structs
3. Chamar métodos dinamicamente
4. Modificar valores - Parece perigoso

O reflect gira em torno de dois tipos principais:

# Mini Servidor de CI/CD – Parte 4: Adicionando testes ao repositório!

Finalizamos a implementação da API e a execução dos pipelines. Agora é hora de garantir que tudo isso funcione como esperado com testes automatizados. Para fazer os testes vamos instalar a go get github.com/stretchr/testify e criar nosso arquivo: internal/api/test/handlers_test.go

Vamos iniciar criando um setup para nossos testes. Para isso vamos criar um banco em memória.

func setupTestRouter() *gin.Engine {
	database, _ := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	db.DB = database
	db.DB.AutoMigrate(&models.Pipeline{}, &models.Step{}, &models.Execution{})

	r := gin.Default()
	api.RegisterRoutes(r)
	return r
}

Primeiro vamos testar a criação de um pipeline. Devemos esperar desse request um retorno de sucesso.

# Mini Servidor de CI/CD – Parte 3: Implementação da API com Gin

Na Parte 2, criamos o banco de dados e modelamos nossas entidades com GORM. Agora, vamos adicionar a camada de API que permitirá: Criar novos pipelines, listar pipelines existentes e executar um pipeline específico. Iremos utilizar o Gin. Teremos dois arquivos novos nessa etapa do projeto o internal/api/routes.go e o internal/api/handlers.go.

No arquivo routes.go, definimos as 3 rotas e quais os handlers de cada rota:

# Mini Servidor de CI/CD – Parte 2: Modelagem e Banco de Dados com GORM

Na Parte 1, iniciamos nosso projeto de servidor CI/CD com Go e o framework Gin, configurando a estrutura de pastas e subindo o servidor com uma rota de teste. Agora vamos persistir os dados dos pipelines e suas execuções com GORM e SQLite. Nosso servidor CI/CD precisa lidar com três entidades principais:

1. Pipeline: representa uma definição de tarefas a serem executadas.
2. Step: cada comando a ser executado dentro do pipeline.
3. Execution: representa uma execução (histórico) de um pipeline.

Primeiro vamos instalar o GORM e o driver do sqlite:

# Mini Servidor de CI/CD – Parte 1: Visão Geral do Projeto

Vamos construir nosso mini servidor de CI/CD com Golang! Nesta “série” de quatro artigos, vamos desenvolver um mini servidor de CI/CD utilizando Golang. Nosso objetivo é criar um sistema simples, porém funcional, que permita: Cadastrar pipelines via API. Listar todos os pipelines existentes. Executar pipelines sob demanda.Persistir informações de execução em banco de dados. Validar a aplicação com testes.

# Hot Reload com Air

Ficar cancelando o go run main.go no terminal ou recompilando manualmente a cada alteração é bem cansativo. Para resolver isso, podemos usar o Air: uma ferramenta de hot reload que detecta mudanças nos arquivos e recompila automaticamente sua aplicação.

Vamos criar um projeto e instalar a dependência:

go install github.com/air-verse/air@latest

E no nosso main.go criar um endpoint bem simples:

package main

import (
	"fmt"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Olá victorstein.dev")
	})
	fmt.Println("Olá victorstein.dev")
	http.ListenAndServe(":8080", nil)
}

Depois rodamos somente um comando:

# Docker e Golang

Neste post, vamos criar uma API simples com Golang usando o framework Gin, e empacotá-la em uma imagem Docker enxuta e pronta para deploy.

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.GET("/", func(c *gin.Context) {
		c.String(http.StatusOK, "Olá do servidor Go com Gin em Docker!")
	})

	r.Run(":8080")
}

Uma das grandes vantagens do Golang é que ele compila o código em um único executável estático. Isso permite criar imagens Docker extremamente leves, contendo apenas o binário da aplicação. Para aproveitar ao máximo essa característica, vamos utilizar um multi-stage build no Docker. Começaremos mostrando o segundo estágio, responsável apenas por rodar o executável final.. Veja como ela será simples, vamos usar a imagem alpine, definir um workdir, copiar nosso executável, e executar o arquivo compilado.

# Panic e Recover

Para fechar a tríplice, vamos falar sobre panic e recover. O Panic é uma função que interrompe o fluxo normal de execução do programa e o recover é uma função que permite capturar um panic e retomar o controle do programa. Ela só funciona dentro de funções defer.

Veja esse exemplo do panic:

func dividir(a, b int) int {
    if b == 0 {
        panic("divisão por zero não é permitida")
    }
    return a / b
}

Se você rodar e executar essa função, o programa vai dar um erro e encerrar. Será que esse é o comportamento que queremos em uma API? Vamos ver como ficaria essa função tratando o erro com um recover: