Go Academy · Aula

Leitura de arquivos de configuração

Carregue YAML, JSON e TOML

Leitura de arquivos de configuração é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Configuração fora do código

Inserir diretamente valores como portas, nomes de host e tempos limite no seu programa Go é uma prática frágil. Viper é a biblioteca de configuração de fato para Go: ela lê configurações de arquivos, variáveis de ambiente, sinalizadores e armazenamentos remotos.

Nesta lição, você carregará a configuração de um arquivo no disco.

Quais formatos o Viper lê

O Viper oferece suporte imediato a vários formatos:

YAML (.yaml / .yml)
JSON (.json)
TOML (.toml)
Arquivos de propriedades HCL, INI e Java

Você escolhe o formato com SetConfigType, ou o Viper o infere a partir da extensão do arquivo.

Instalando e importando o Viper

Adicione o Viper ao seu módulo e importe-o:

go get github.com/spf13/viper
import "github.com/spf13/viper"

Como o Viper é uma dependência externa, os trechos que o importam não podem ser executados no reprodutor desta lição. Simulamos o comportamento com a biblioteca padrão sempre que possível.

import "github.com/spf13/viper"

Indicando ao Viper onde procurar

Configure o nome, o tipo e os caminhos de pesquisa do arquivo antes de fazer a leitura:

viper.SetConfigName("config") define o nome base (sem extensão)
viper.SetConfigType("yaml") define o formato
viper.AddConfigPath(".") adiciona um diretório à pesquisa

viper.SetConfigName("config")
viper.SetConfigType("yaml")
viper.AddConfigPath(".")
viper.AddConfigPath("/etc/myapp")

Lendo o arquivo

Chame viper.ReadInConfig() para carregar o arquivo. Ele retorna um erro que você deve verificar:

Um arquivo ausente retorna um ConfigFileNotFoundError
Um arquivo malformado retorna um erro de análise

if err := viper.ReadInConfig(); err != nil {
    log.Fatalf("failed to read config: %v", err)
}

Uma configuração YAML de exemplo

Imagine um config.yaml como este. O Viper converte chaves aninhadas em chaves planas usando pontos, portanto a porta se torna server.port.

server:
  port: 8080
  host: "localhost"
debug: true

Obtendo valores tipados

O Viper oferece funções de acesso tipadas, evitando conversões manuais:

viper.GetInt("server.port")
viper.GetString("server.host")
viper.GetBool("debug")

port := viper.GetInt("server.port")
host := viper.GetString("server.host")
debug := viper.GetBool("debug")
fmt.Println(host, port, debug)

JSON funciona da mesma forma

Mudar para JSON altera apenas o conteúdo do arquivo e o tipo de configuração. Os mesmos caminhos de chaves e funções de acesso continuam válidos. Essa portabilidade explica por que o Viper é popular: seu código não precisa saber qual formato a equipe de operações escolheu.

{
  "server": { "port": 8080, "host": "localhost" },
  "debug": true
}

O TOML também é compatível

O TOML é comum no ecossistema Go (muitas interfaces de linha de comando o usam). As mesmas chaves aninhadas correspondem a caminhos separados por pontos.

[server]
port = 8080
host = "localhost"

debug = true

Analisando JSON com a biblioteca padrão

Para ver a ideia funcionando de verdade, aqui está um programa Go simples que analisa uma configuração JSON sem Viper, usando apenas encoding/json em um mapa (o próprio Viper funciona sobre um mapa genérico internamente).

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    raw := "{\"port\":8080,\"host\":\"localhost\"}"
    var c map[string]any
    if err := json.Unmarshal([]byte(raw), &c); err != nil {
        panic(err)
    }
    fmt.Printf("%v:%v\n", c["host"], c["port"])
}

Executável: lendo em um mapa

Este programa independente analisa uma configuração JSON em um mapa genérico e imprime os valores, reproduzindo o que o Viper faz internamente com JSON.

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    raw := "{\"port\":8080,\"host\":\"localhost\"}"
    var m map[string]any
    json.Unmarshal([]byte(raw), &m)
    fmt.Println("host:", m["host"])
    fmt.Println("port:", m["port"])
}

Verificação rápida

Teste seus conhecimentos sobre a leitura de arquivos de configuração com o Viper.

Recapitulação

Você aprendeu como o Viper lê arquivos de configuração:

Ele oferece suporte transparente a YAML, JSON e TOML
Configure-o com SetConfigName, SetConfigType e AddConfigPath
ReadInConfig() carrega o arquivo e retorna um erro
Funções de acesso tipadas, como GetInt e GetString, leem valores por uma chave com pontos

A seguir: substituindo a configuração com variáveis de ambiente.

Perguntas Frequentes

A aula “Leitura de arquivos de configuração” é grátis?

Sim — o texto completo de “Leitura de arquivos de configuração” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Leitura de arquivos de configuração”?

Carregue YAML, JSON e TOML Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Leitura de arquivos de configuração”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy