Como usar hot reload em Go
Tags: go, backend, tutorial, tooling
Published: 2023-11-12 11:00:00

Quando dei os primeiros passos no estudo de Golang, optei por usar o Chi para gerenciar as rotas da minha primeira API. Contudo, me deparei com a ausência de um recurso essencial: o hot reload. Em busca de aprimorar meu processo de desenvolvimento, cai de cabeça em pesquisas na internet. Infelizmente, não encontrei soluções simples, mas achei algumas alternativas como executar o Go em um nodemon, o que me causou certo desconforto. Afinal, por que misturar Go com Node?

Foi então que me deparei com o [taskfile.dev](https://taskfile.dev/). O Task é uma ferramenta de automação projetada para ser mais acessível do que outras opções, como o [GNU Make](https://www.gnu.org/software/make/).

Sendo desenvolvido em [Go](https://go.dev/), o Task é um binário simples, sem nenhuma outra dependência. Isso significa que você não enfrentará complicações durante o processo de instalação, tornando a utilização desta ferramenta de automação uma experiência descomplicada.

Para começar, é crucial realizar a instalação do `taskfile`. Siga as instruções do manual de instalação disponível em [https://taskfile.dev/installation/](https://taskfile.dev/installation/). 

Após a instalação, precisamos criar um arquivo para configurar o taskfile em seu projeto. Portanto, no diretório raiz do seu projeto crie o arquivo `taskfile.yml` com o seguinte conteúdo:

```yml
version: '3'

tasks:
  :build:
    cmds:
      - 'go build -o dist/main ./main.go'
    sources:
      - ./*.go,
      - ./**/*.go

  :start:
    cmds:
      - task: :build
      - './dist/main'
    sources: 
      - ./*.go,
      - ./**/*.go
```
O arquivo `taskfile.yml` contém instruções para a ferramenta de automação `task` (ou `go-task`) sobre como executar diferentes tarefas relacionadas ao desenvolvimento do projeto em Go. Vamos analisar o conteúdo do arquivo:

```yml
version: '3'

tasks:
  :build:
    cmds:
      - 'go build -o dist/main -mod=vendor ./cmd/main.go'
    sources:
      - ./*.go
      - ./**/*.go

  :start:
    cmds:
      - task: :build
      - './dist/main'
    sources:
      - ./*.go
      - ./**/*.go
```

1. **Versão do Taskfile:** A primeira linha especifica a versão do `taskfile` que está sendo usada.

2. **Definição de Tarefas:**
   - `:build`: Esta tarefa compila o projeto Go. Ela usa o comando `go build` para compilar o código-fonte localizado em `./main.go` e salva o executável resultante em `dist/main`. 
   - `:start`: Esta tarefa depende da tarefa `:build` e, em seguida, executa o executável gerado (`./dist/main`). Isso proporciona uma maneira de compilar e iniciar o aplicativo com um único comando.

3. **Sources:**
   - Ambas as tarefas têm uma lista de sources que indicam quais arquivos ou diretórios devem ser observados para acionar a execução da tarefa quando houver alterações. Isso é útil para usar o hot reload, pois permite que o `task` detecte mudanças nos arquivos e execute automaticamente as tarefas relacionadas.

4. **Comando para Execução:**
   - Os comandos sob a chave `cmds` são os comandos reais executados pela tarefa. Eles são escritos como se fossem comandos de terminal padrão.

Depois de configurar esse `taskfile.yml` e instalar o `task`, você pode usar o comando `go-task :start -w --interval=500ms` para compilar e iniciar seu aplicativo, com a capacidade de hot reload sempre que houver alterações nos arquivos especificados. Este processo simplifica o ciclo de desenvolvimento.

> Dica: se isso não funcionar, tente substituir `go-task` por `task`.

Em resumo, a integração do `taskfile` em projetos Go oferece uma solução elegante para a gestão de tarefas de desenvolvimento, como compilação e execução do aplicativo, especialmente quando se trata da necessidade crucial de hot reload. Ao adotar o `taskfile`, você obtém uma ferramenta de automação simples, baseada em Go, eliminando a necessidade de soluções mais complexas e mistas. A configuração apresentada no `taskfile.yml` permite compilar e iniciar o aplicativo com facilidade, enquanto o monitoramento contínuo das alterações nos arquivos facilita a atualização automática, proporcionando um fluxo de desenvolvimento mais eficiente e livre de complicações. Ao incorporar essa abordagem em seu fluxo de trabalho, você maximiza a produtividade e mantém o foco no desenvolvimento de qualidade em vez de lidar com tarefas manuais repetitivas.