YAML est un format populaire de sérialisation de données lisibles par l’homme. Ce langage de données convient aux fichiers de configuration, à l’échange de données et au stockage de données structurées.
De nombreux projets basés sur Go, y compris Gqlgen et des outils de construction comme Docker-compose, utilisent des fichiers YAML pour la configuration. En tant que développeur Go, vous pouvez utiliser des outils tels que le paquetage yaml pour analyser et manipuler les données YAML.
Comprendre un fichier YAML
Les fichiers YAML (YAML Ain’t Markup Language) sont constitués de paires clé-valeur, de listes et de structures imbriquées. La syntaxe YAML est conçue pour être visuellement attrayante et facile à lire. Cela en fait un choix populaire pour les fichiers de configuration, avec Kubernetes et d’autres outils d’orchestration utilisant YAML.
Contrairement à d’autres formats de données tels que XML et JSON, YAML s’appuie sur l’indentation pour représenter la hiérarchie.
Voici comment définir des champs de base en YAML :
name: John Doe
age: 30
email: john.doe@example.com
Un deux-points sépare la clé de sa valeur, qui peut être n’importe quel type de données YAML valide, y compris des chaînes, des nombres, des booléens ou des structures imbriquées.
Les listes permettent de représenter une collection de valeurs. Pour définir une liste en YAML, utilisez un trait d’union suivi d’un espace avant chaque élément :
fruits:
- apple
- banana
- orange
Ici, fruits est la clé, et les lignes avec trait d’union définissent une liste de fruits.
YAML prend également en charge les structures imbriquées, ce qui permet de représenter des hiérarchies de données complexes :
person:
name: John Doe
age: 30
address:
street: 123 Main St
city: Anytown
country: USA
La structure personne contient un autre ensemble de paires clé-valeur, formant une structure imbriquée. La clé adresse possède son propre ensemble de paires clé-valeur.
Travailler avec YAML en Go
Go ne fournit pas de fonctionnalité intégrée pour les fichiers YAML, mais il existe des paquets tiers qui le font.
La fonction yaml est un paquetage populaire pour travailler avec des fichiers YAML. Il fournit :
- Des fonctionnalités d’analyse et de sérialisation.
- Prise en charge des balises YAML.
- Conformité complète à la spécification YAML.
- Contrôle fin sur le marshalling et le unmarshalling.
- Gestion des erreurs.
- Compatibilité avec plusieurs versions de YAML.
Ouvrez votre terminal et exécutez cette commande pour installer le paquetage YAML pour votre projet :
# install version 3 of the yaml package
go get gopkg.in/yaml.v3
Après avoir installé le paquetage, vous pouvez utiliser la commande import pour importer le paquet dans vos fichiers Go.
import "gopkg.in/yaml.v3"
Vous pouvez choisir plusieurs versions de YAML en fonction de la version de la spécification YAML que vous souhaitez utiliser.
Lecture et analyse de YAML pour les structures de données Go
L’une des tâches essentielles que vous voudrez effectuer est d’analyser YAML pour en faire des structures de données Go. L’analyse des structures de données YAML vers Go est une tâche essentielle que vous devrez effectuer. yaml fournit une API simple et pratique pour ce faire.
Considérons ces données YAML :
# output.yaml
person:
name: John Doe
age: 30
email: john.doe@example.com
Vous pouvez définir une structure correspondante avec des noms de champs correspondants pour analyser les données YAML dans une structure de données Go avec la fonction yaml paquet.
// Person struct represents the person key in YAML.
type Person struct {
Name string `yaml:"name"`
Age int `yaml:"age"`
Email string `yaml:"email"`
}
Le yaml Les balises struct permettent de faire correspondre les clés YAML aux champs struct lors de l’opération d’analyse.
Voici comment analyser les données YAML dans une structure de données Go :
import (
"fmt"
"gopkg.in/yaml.v3"
"os"
)
func main() {
// read the output.yaml file
data, err := os.ReadFile("output.yaml")
if err != nil {
panic(err)
}
// create a person struct and deserialize the data into that struct
var person Person
if err := yaml.Unmarshal(data, &person); err != nil {
panic(err)
}
// print the fields to the console
fmt.Printf("Name: %s\n", person.Name)
fmt.Printf("Age: %d\n", person.Age)
fmt.Printf("Email: %s\n", person.Email)
}
L’outil principal La fonction output.yaml avec le fichier ioutil paquet de FichierLecture . Elle crée ensuite une instance de la fonction Personne et analyse les données dans la structure à l’aide de la fonction Unmarshal méthode de la yaml paquet. Le paquet principal imprime les champs de l’instance struct ; voici le résultat :
Insérer des données dans un fichier YAML
Vous pouvez utiliser les structures de données Go pour insérer des données dans les fichiers YAML. Voici comment vous pouvez insérer des données dans un fichier YAML avec une instance de la structure de données Personne struct :
func main() {
// Create an instance of the Person struct with sample data
person := Person{
Name: "John Doe",
Age: 30,
Email: "john.doe@example.com",
}
// Serialize the person struct into YAML format
data, err := yaml.Marshal(&person)
if err != nil {
panic(err)
}
// Write the serialized YAML data to a file named "output.yaml"
err = os.WriteFile("output.yaml", data, 0644)
if err != nil {
panic(err)
}
fmt.Println("Data written to output.yaml")
}
Le personne est une instance de la variable Personne type de structure. Utiliser le type Maréchal méthode de la yaml pour convertir la structure en YAML. Il prend l’instance de la structure et renvoie la représentation YAML ainsi qu’une erreur.
Vous pouvez utiliser le paquetage WriteFile de la fonction os pour écrire les données YAML dans votre fichier (dans ce cas, output.yaml).
Après une opération réussie de sérialisation et d’écriture de données YAML, la fonction principal imprime un message sur la console.
Vous pouvez marshaler et démarshaler YAML dans des maps comme vous le faites avec les structs.
Voici un exemple de marshalling et de unmarshalling de données YAML avec des maps :
package main
import (
"fmt"
"gopkg.in/yaml.v3"
)
func main() {
// Data for marshaling
data := map[string]interface{}{
"name": "John Doe",
"age": 30,
"email": "johndoe@example.com",
}
// Marshaling the data into YAML
yamlData, err := yaml.Marshal(data)
if err != nil {
fmt.Println("Error during marshaling:", err)
return
}
fmt.Println("Marshaled YAML data:")
fmt.Println(string(yamlData))
// Unmarshalling the YAML data into a map
var unmarshalledData map[string]interface{}
err = yaml.Unmarshal(yamlData, &unmarshalledData)
if err != nil {
fmt.Println("Error during unmarshalling:", err)
return
}
fmt.Println("\nUnmarshalled data:")
fmt.Println(unmarshalledData)
}
Le processus est le même que pour les types struct, sauf que vous utilisez des cartes pour la représentation des données. Les Unmarshal et Maréchal fonctionnent pour les deux types de données.
Docker Compose utilise des fichiers YAML pour la configuration
Travailler avec des fichiers YAML dans Go offre une approche puissante et flexible pour gérer les données de configuration.
Un cas d’utilisation important des fichiers YAML est Docker Compose, où un fichier YAML sert de configuration pour définir et gérer des applications Docker multi-conteneurs.
Docker Compose exploite la simplicité et la lisibilité de YAML pour définir les services, les réseaux, les volumes et d’autres composants des applications conteneurisées afin de faciliter l’orchestration des conteneurs.
