Hvordan jobbe med YAML-filer i Go

YAML er et populært, menneskelig lesbart dataserialiseringsformat. Dataspråket er egnet for konfigurasjonsfiler, datautveksling og strukturert datalagring.

Mange Go-baserte prosjekter, inkludert Gqlgen og byggeverktøy som Docker-compose, bruker YAML-filer for konfigurasjon. Som Go-utvikler kan du bruke verktøy som yaml-pakken til å analysere og manipulere YAML-data.

Forstå en YAML-fil

YAML-filer (YAML Ain't Markup Language) består av nøkkelverdi-par, lister og nestede strukturer. YAML-syntaks er designet for å være visuelt tiltalende og lett å lese. Dette gjør det til et populært valg for konfigurasjonsfiler, med Kubernetes og andre orkestreringsverktøy ved hjelp av YAML.

I motsetning til andre dataformater som XML og JSON, YAML er avhengig av innrykk for å representere hierarki.

Slik kan du definere grunnleggende felt med YAML:

Navn:JohnDoe
alder:30
e-post:[email protected]

Et kolon skiller nøkkelen fra dens verdi, som kan være en hvilken som helst gyldig YAML-datatype, inkludert strenger, tall, booleaner eller nestede strukturer.

Lister lar deg representere en samling verdier. For å definere en liste i YAML, bruk en bindestrek etterfulgt av et mellomrom før hvert element:

frukt:
-eple
-banan
-oransje

Her, frukt er nøkkelen, og bindestrekene definerer en liste over frukter.

YAML støtter også nestede strukturer, slik at du kan representere komplekse datahierarkier:

person:
Navn:JohnDoe
alder:30
adresse:
gate:123HovedSt
by:Anytown
land:USA

De person nøkkel inneholder et annet sett med nøkkelverdi-par, som danner en nestet struktur. De adresse nøkkel har sitt eget sett med nøkkelverdi-par.

Arbeide med YAML i Go

Go gir ikke innebygd funksjonalitet for YAML-filer, men det er tredjepartspakker som gjør det.

De yaml pakke er en populær pakke for arbeid med YAML-filer. Det gir:

• Parsing og serialiseringsfunksjoner.
• Støtte for YAML-tagger.
• Omfattende YAML-spesifikasjonsoverholdelse.
• Finmasket kontroll over rangering og unmarshalling.
• Feilhåndtering.
• Kompatibilitet med flere YAML-versjoner.

Åpne terminalen og kjør denne kommandoen for å installere YAML-pakken for prosjektet ditt:

# installer versjon 3 av yaml-pakken
gå til gopkg.in/yaml.v3

Etter å ha installert pakken, kan du bruke import uttalelse for å importere pakken til Go-filene dine.

import"gopkg.in/yaml.v3"

Du kan velge flere YAML-versjoner basert på versjonen av YAML-spesifikasjonen du vil bruke.

Lese og analysere YAML to Go-datastrukturer

En viktig oppgave du vil utføre er å analysere YAML to Go-datastrukturer. De yaml pakken gir en enkel, praktisk API for å gjøre dette.

Tenk på disse YAML-dataene:

# output.yaml
person:
Navn:JohnDoe
alder:30
e-post:[email protected]

Du kan definere en tilsvarende struktur med samsvarende feltnavn for å analysere YAML-dataene til en Go-datastruktur med yaml pakke.

// Person struct representerer personnøkkelen i YAML.
type Person struktur {
 Navn streng`yaml:"navn"`
 Alder int`yaml:"alder"`
 E-post streng`yaml:"e-post"`
}

De yaml struct-tagger hjelper til med å kartlegge YAML-nøklene til struct-feltene under analyseoperasjonen.

Slik kan du analysere YAML-dataene til en Go-datastruktur:

import (
"fmt"
"gopkg.in/yaml.v3"
"os"
)
funchoved-() {
// les output.yaml-filen 
 data, feil := os. ReadFile("output.yaml")
hvis feil!= null {
panikk(feil)
 }

// lag en personstruktur og deserialiser dataene til den strukturen
var person Person
hvis feil := yaml. Unmarshal (data, &person); feil!= null {
panikk(feil)
 }

// skriv ut feltene til konsollen
 fmt. Printf("Navn: %s\n", person. Navn)
 fmt. Printf("Alder: %d\n", person. Alder)
 fmt. Printf("E-post: %s\n", person. e-post)
}

De hoved- funksjonen leser output.yaml fil med ioutil pakkens ReadFile funksjon. Det oppretter deretter en forekomst av Person struct og analyserer dataene inn i strukturen med Unmarshal metoden for yaml pakke. De hoved- funksjonen skriver ut feltene fra struct-forekomsten; her er resultatet:

Sette inn data i en YAML-fil

Du kan bruke Go-datastrukturer til å sette inn data i YAML-filer. Slik kan du sette inn data til en YAML-fil med en forekomst av Person struktur:

funchoved-() {
// Opprett en forekomst av Person-strukturen med eksempeldata
 person := person{
 Navn: "John Doe",
 Alder: 30,
 E-post: "[email protected]",
 }
// Serialiser personstrukturen til YAML-format
 data, feil := yaml. Marshal (&person)
hvis feil!= null {
panikk(feil)
 }
// Skriv de serialiserte YAML-dataene til en fil som heter "output.yaml"
 feil = os. Skriv fil("output.yaml", data, 0644)
hvis feil!= null {
panikk(feil)
 }
 fmt. Println("Data skrevet til output.yaml")
}

De person variabel er en forekomst av Person strukturtype. Bruke Marskalk metoden for yaml pakke for å konvertere strukturen til YAML. Den tar forekomsten av strukturen og returnerer YAML-representasjonen og en feil.

Du kan bruke Skriv fil funksjonen til os pakke for å skrive YAML-dataene til filen din (i dette tilfellet, output.yaml).

Etter en vellykket YAML-dataserialisering og skriveoperasjon, hoved- funksjonen skriver ut en melding til konsollen.

Du kan sette opp og sette YAML inn i kart som du gjør med strukturer.

Her er et eksempel på rangering og demontering av YAML-data med kart:

pakke hoved-
import (
"fmt"
"gopkg.in/yaml.v3"
)
funchoved-() {
// Data for marshaling
 data := kart[streng]grensesnitt{}{
"Navn": "John Doe",
"alder": 30,
"e-post": "[email protected]",
 }
// Sorterer dataene inn i YAML
 yamlData, feil := yaml. Marshal (data)
hvis feil!= null {
 fmt. Println("Feil under rangering:", feil)
komme tilbake
 }
 fmt. Println("Marshaled YAML-data:")
 fmt. Println(streng(yamlData))
// Unmarshalling YAML data til et kart
var unmarshalledData kart[streng]grensesnitt{}
 feil = yaml. Unmarshal (yamlData, &unmarshalledData)
hvis feil!= null {
 fmt. Println("Feil under unmarshalling:", feil)
komme tilbake
 }
 fmt. Println("\nUrangerte data:")
 fmt. Println (unmarshalledData)
}

Prosessen er den samme som for strukturtyper, bortsett fra at du bruker kart for datarepresentasjonen. De Unmarshal og Marskalk metoder fungerer for begge datatyper.

Docker Compose bruker YAML-filer for konfigurasjon

Arbeid med YAML-filer i Go gir en kraftig og fleksibel tilnærming for å administrere konfigurasjonsdata.

Et fremtredende bruksområde for YAML-filer er Docker Compose, der en YAML-fil fungerer som konfigurasjonen for å definere og administrere Docker-applikasjoner med flere beholdere.

Docker Compose utnytter enkelheten og lesbarheten til YAML for å definere tjenester, nettverk, volumer og andre komponenter i containeriserte applikasjoner for å gjøre containerorkestrering enkelt.