Go Academy · Leçon

Lire des fichiers de configuration

Charger YAML, JSON et TOML

Lire des fichiers de configuration est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

La configuration hors du code

Inscrire en dur des valeurs comme les ports, les noms d’hôte et les délais d’attente dans votre programme Go est fragile. Viper est la bibliothèque de configuration de facto pour Go : elle lit les paramètres depuis des fichiers, des variables d’environnement, des options et des stockages distants.

Dans cette leçon, vous chargez la configuration depuis un fichier sur le disque.

Formats lus par Viper

Viper prend en charge de nombreux formats immédiatement :

YAML (.yaml / .yml)
JSON (.json)
TOML (.toml)
fichiers de propriétés HCL, INI et Java

Vous choisissez le format avec SetConfigType, ou Viper le déduit de l’extension du fichier.

Installer et importer Viper

Ajoutez Viper à votre module et importez-le :

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

Viper étant une dépendance externe, les extraits qui l’importent ne sont pas exécutables dans ce lecteur de leçons. Lorsque c’est possible, nous simulons son comportement avec la bibliothèque standard.

import "github.com/spf13/viper"

Indiquer à Viper où chercher

Configurez le nom, le type et les chemins de recherche du fichier avant de le lire :

viper.SetConfigName("config") définit le nom de base, sans extension
viper.SetConfigType("yaml") définit le format
viper.AddConfigPath(".") ajoute un répertoire aux emplacements de recherche

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

Lire le fichier

Appelez viper.ReadInConfig() pour charger le fichier. Cette fonction renvoie une erreur que vous devez vérifier :

Un fichier manquant renvoie une ConfigFileNotFoundError
Un fichier mal formé renvoie une erreur d’analyse

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

Exemple de configuration YAML

Imaginez un fichier config.yaml comme celui-ci. Viper aplatit les clés imbriquées en utilisant des points : le port devient donc server.port.

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

Obtenir des valeurs typées

Viper fournit des accesseurs typés, ce qui vous évite les conversions manuelles :

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 fonctionne de la même manière

Passer à JSON ne modifie que le contenu du fichier et le type de configuration. Les mêmes chemins de clés et les mêmes accesseurs s’appliquent. Cette portabilité explique la popularité de Viper : votre code ne dépend pas du format choisi par les équipes d’exploitation.

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

TOML est également pris en charge

TOML est courant dans l’écosystème Go, où de nombreux outils en ligne de commande l’utilisent. Les mêmes clés imbriquées correspondent à des chemins séparés par des points.

[server]
port = 8080
host = "localhost"

debug = true

Analyser du JSON avec la bibliothèque standard

Pour voir cette idée fonctionner concrètement, voici une analyse de configuration JSON en Go standard, sans Viper, qui utilise uniquement encoding/json pour remplir une table associative (Viper fonctionne lui-même sur une table associative générique en interne).

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"])
}

Exécutable : lire dans une table associative

Ce programme autonome analyse une configuration JSON dans une table associative générique et affiche les valeurs, reproduisant ce que Viper fait en interne pour 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"])
}

Vérification rapide

Vérifiez votre compréhension de la lecture des fichiers de configuration avec Viper.

Récapitulatif

Vous avez appris comment Viper lit les fichiers de configuration :

Il prend en charge YAML, JSON et TOML de manière transparente
Configurez-le avec SetConfigName, SetConfigType et AddConfigPath
ReadInConfig() charge le fichier et renvoie une erreur
Les accesseurs typés comme GetInt et GetString lisent les valeurs à partir d’une clé séparée par des points

Ensuite : remplacer la configuration avec des variables d’environnement.

Questions Fréquemment Posées

La leçon « Lire des fichiers de configuration » est-elle gratuite ?

Oui — le texte complet de « Lire des fichiers de configuration » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Lire des fichiers de configuration » ?

Charger YAML, JSON et TOML Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Lire des fichiers de configuration » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy