Go + hot reload
Tags: go, tutorial, portugues
Published: 2024-02-23 15:05:19

---
title: Go + hot reload
published: true
description: 
tags: #go #golang #tutorial #portugues
# cover_image: 
# Use a ratio of 100:42 for best results.
# published_at: 2024-02-23 12:05 +0000
---
> Esse post é uma dica rápida para ajudar o desenvolvimento de aplicações Go ficar mais dinâmico e rápido.

## Contexto

Go é uma linguagem compilada, qualquer alteração no código da sua aplicação exige que você re-compile e execute novamente.
Isso por si, não é um grande problema, pois a compilação e startup do Go é super rápido e provavelmente sua IDE tem um botão pronto para restart da aplicação.
Porém é um pouco inconveniente, e nos tira algum tempo lembrar de restartar, automatizar esse processo nos deixa mais produtivos.


## Ferramenta Reflex

O reflex é uma ferramenta open source escrita em Go, ela basicamente faz watch de um diretório e quando identifica alteração de arquivos re-executa um comando.

### Exemplo de uso


Instale o reflex:
```bash
go install github.com/cespare/reflex@v0.3.1
```

Execute o reflex:
```
reflex -s -r '\.go$$' -- go run .
```

Simples assim, nesse comando eu estou passando a flag `-s` para sinalizar que é um processo de longa duração e a flag `-r` para filtrar somente os arquivos `.go`.

Log de exemplo:

```
reflex -s -r '\.go$' -- go run .
[00] Starting service
[00] [GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
[00]  - using env:      export GIN_MODE=release
[00]  - using code:     gin.SetMode(gin.ReleaseMode)
[00] 
[00] 2024/02/23 09:12:50 Failed to connect to rabbit  dial tcp [::1]:5672: connect: connection refused
[00] 2024/02/23 09:12:50 Skipping queue setup 
[00] [GIN-debug] POST   /endpoints/               --> api/api.Handler.PostEndpoints-fm (1 handlers)
[00] [GIN-debug] GET    /endpoints/               --> api/api.Handler.GetEndpoints-fm (1 handlers)
...
[00] [GIN-debug] Listening and serving HTTP on :3000

```

Para mais informações de como usar o `reflex`, consulte o repositório no github: https://github.com/cespare/reflex

### Usando Makefile

O seu comando `reflex` pode acabar aumentando de acordo com as configurações do seu projeto. Para não precisar ficar digitando ele várias vezes, você pode utilizar um arquivo Makefile no seu projeto, assim por exemplo:

```make

dev:
	reflex -s -r '\.go$$' -- go run .
```
Com isso você só precisa utilizar `make dev` e pronto.

## Utilizando com Docker

Se o seu projeto utiliza `docker-compose` para inicializar as dependências que precisam subir com seu servidor, você também pode se beneficiar do hot reload.
Você consegue alcançar isso em 3 etapas:

- Criando o Makefile na raiz do projeto, como foi apresentado acima.

- Crie um Dockerfile **somente para desenvolvimento**:


*Dockerfile.local*
```docker
FROM golang:1.22.0-bullseye
WORKDIR /app

RUN go install github.com/cespare/reflex@v0.3.1
```

- Adicione `command` no seu service do docker-compose:

```yaml
  seu-service:
    build:
      context: .
      dockerfile: Dockerfile.local
    volumes:
      - .:/app
    depends_on:
      - rabbitmq
    command: ['make', 'dev']
```

Com isso você pode executar seu `docker compose up --build` normalmente, todos seus containers vão subir e seu servidor em Go vai fazer hot reload quando você editar os arquivos `.go`.

Ou seja, você não precisa reiniciar ou reconstruir seu container a cada alteração de código. Deixe para fazer isso quando tiver mudanças de infraestrutura.