Debug Golang com VSCode

Opa, fala aí, pessoal, tudo beleza!? Depois de muito tempo sem escrever algo eu estou aparecendo aqui com esse mini tutorial (ou “how to” como alguns chamam) para explicar como configurar o VSCode para que se possa debugar ao desenvolver em Go (Golang). A minha principal motivação vem da galera com a qual eu trabalho, pois muitos têm dado preferência a utilizar o VSCode para desenvolver e, quando eles precisam de alguma ajuda ou tem alguma dúvida, que eu paro para tentar ajudá-los, eles colocam alguns println para entender o fluxo do sistema e para tentar saber o valor que determinada variável possui e por aí vai. Com isso, acabam repetindo as mesmas ações e outras coisas mais que acabam dificultando o entendimento e a resolver a questão. Como eu sou de uma geração um pouco mais antiga, eu desde cedo fui moldado a utilizar o debug na qual as IDEs disponibilizam e eu achei estranho - até meio improdutivo, isso alinhado a tortura do println - essa galera mais nova adicionar um monte de println ao código e depois sair removendo tudo quando vão realizar o commit.

Bem. Eu já falei (eu quis dizer escrever, mas você entendeu) demais. Vamos ao que interessa!

Sumário

• Sistema e Configurações
• Pré-Requisitos
  • Instalar Go no VSCode
  • Instalar o DLV no VSCode
• Template básico do arquivo de configuração
• Configurando o projeto
• Inicializando a aplicação no modo debug
• Conclusão
• Referências
• Apêndices

Sistema e Configurações

• Pop!_OS versão 22.04 LTS em Máquina Virtual (VM);
• Go na versão 1.19.4 instalado via GVM;
• VSCode versão 1.74.1 instalado via flatpak;

Pré-Requisitos

Instalar Go no VSCode

Para esse tutorial foi utilizado a extensão Go na versão 0.37.0 da empresa Go team at Google.

Instalar o DLV no VSCode

Para tirar maior proveito na manutenção e assim manter atualizado o modo debug, pode-se utilizar o dlv. O jeito mais fácil de instalar o dlv é utilizar o comando "Go: Install/Update Tools" na paleta de comando do VSCode (Linux/Windows: Ctrl+Shift+P). O comando mostrará o dlv na listagem de ferramentas.

Template básico do arquivo de configuração

Para usar o modo debug no VSCode será necessário ter na raíz do projeto a pasta .vscode e dentro dela o arquivo launch.json, assim ficando /.vscode/launch.json.

Exemplo:

| raíz_projeto
| - .vscode
| - - launch.json

A seguir, um template básico do launch.json.

 {
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Run Name",
            "type": "go",
            "request": "launch",
            "mode": "debug",
            "program": "${workspaceFolder}",
            "env": {},
            "args": [],
            "showLog": true
        }
    ]
}

${workspaceFolder} é uma variável de ambiente gerada pelo VSCode que corresponde ao diretório raíz da aplicação.

Configurando o projeto

Para ter um exemplo mais concreto do uso será utilizado um projeto de exemplo como base para demonstrar as configurações.

Estrutura base do projeto:

| test-debug
| - .vscode
| - - launch.json
| - cmd
| - - main.go
| - envfile.env
| - go.mod

É possível ter mais de uma configuração no mesmo launch.json para ser utilizada de acordo com a necessidade, ou seja, é desnecessário ter mais de um launch.json ou então ficar alterando as configurações do mesmo para obter configurações diferentes. Em outras palavras, significa que dentro do mesmo launch.json é possível ter uma configuração para inicializar a aplicação com configurações para ambiente de dev, ambiente de homologação, de produção e assim por diante.

Vejamos a seguir exemplo de configuração para inicializar a aplicação:

• Arquivo launch.json:

  {
      "version":"0.2.0",
      "configurations":[
          {
              "name":"Test: Simple",
              "type":"go",
              "request":"launch",
              "mode":"debug",
              "program":"${workspaceFolder}/cmd",
              "env":{},
              "args":[],
              "showLog":true
          },
          {
              "name":"Test: Env And Args",
              "type":"go",
              "request":"launch",
              "mode":"debug",
              "program":"${workspaceFolder}/cmd",
              "envFile":"${workspaceFolder}/envfile.env",
              "env":{
                  "HOST":"test.com"
              },
              "args":[
                  "redirect",
                  "test"
              ],
              "showLog":true
          }
      ]
  }
  

Repare que na configuração que corresponde a Test: Env And Args foi utilizado um arquivo que contém algumas variáveis de ambiente, *, tem o *env no qual é possível também declarar variáveis de ambiente e o args, que é utilizado para passar argumentos a aplicação. Todos esses atributos possibilitam passar dados a aplicação.

• Arquivo envfile.env:

  ENVIRONMENT=dev
  MESSAGE=HELLO WORLD!
  

Desta forma, seria possível externalizar num arquivo .env as variáveis de ambiente que são comuns aos ambientes, ou seja, simplifica a configuração.

• Arquivo main.go:

  package main
  import (
      "fmt"
      "os"
  )
  
  func main() {
      HOST := os.Getenv("HOST")
      MESSAGE := os.Getenv("MESSAGE")
      ENVIRONMENT := os.Getenv("ENVIRONMENT")
      args := os.Args
  
      // without these println there is a compile error
      fmt.Println(fmt.Sprintf("Host: %s; Message: %s; Environment: %s", HOST, MESSAGE, ENVIRONMENT))
  
      for  i, arg := range args {
          fmt.Println(fmt.Sprintf("arg(%d): %s ", i, arg))
      }
  
  }
  

Ao executar o programa será possível visualizar todas as variáveis e seus respectivos valores no painel de variáveis do VSCode.

Inicializando a aplicação no modo debug

Para inicializar a aplicação é bem simples, só seguir os seguintes passos:

1. clicar no ícone Run and Debug que fica, por padrão, do lado esquerdo do VSCode;
2. selecionar qual configuração do launch.json se deseja executar;
3. adicionar breakpoint no ponto que deseja pausar a execução da aplicação;
4. clicar no botão Start Debugging (F5) - ou Iniciar Depuração (F5).

Conclusão

Com o passo-a-passo descrito eu espero que agora seja possível configurar o ambiente de desenvolvimento, fazendo uso das configurações no launch.json e, a debuggar a aplicação, para que se possa acompanhar o fluxo do sistema e suas variáveis, desta forma, melhorando a produtividade e o entendimento durante o desenvolvimento.

Referências

• https://github.com/golang/vscode-go/blob/master/docs/debugging.md
• https://www.digitalocean.com/community/tutorials/debugging-go-code-with-visual-studio-code

Apêndices

A seguir algumas informações sobre as tecnologias utilizadas para desenvolver esse exemplo de aplicação:

• SO utilizado Pop!_OS versão 22.04 LTS
• Máquina Virtual (VM) foi utilizado o Gnome Boxes via flatpak;
• Go na versão 1.19.4 instalado via GVM;
• VSCode versão 1.74.1 instalado via flatpak;