Como trabalhar com arquivos YAML em Go

YAML é um formato popular de serialização de dados legíveis por humanos. A linguagem de dados é adequada para arquivos de configuração, troca de dados e armazenamento de dados estruturados.

Muitos projetos baseados em Go, incluindo Gqlgen e ferramentas de construção como Docker-compose, usam arquivos YAML para configuração. Como desenvolvedor Go, você pode usar ferramentas como o pacote yaml para analisar e manipular dados YAML.

Compreendendo um arquivo YAML

Os arquivos YAML (YAML Ain't Markup Language) consistem em pares chave-valor, listas e estruturas aninhadas. A sintaxe YAML foi projetada para ser visualmente atraente e fácil de ler. Isso o torna uma escolha popular para arquivos de configuração, com Kubernetes e outros ferramentas de orquestração usando YAML.

Ao contrário de outros formatos de dados como XML e JSON, o YAML depende do recuo para representar a hierarquia.

Veja como você pode definir campos básicos com YAML:

nome:JohnCorça
idade:30
e-mail:[email protected]

Dois pontos separam a chave de seu valor, que pode ser qualquer tipo de dados YAML válido, incluindo strings, números, booleanos ou estruturas aninhadas.

As listas permitem que você represente uma coleção de valores. Para definir uma lista em YAML, use um hífen seguido de um espaço antes de cada item:

frutas:
-maçã
-banana
-laranja

Aqui, frutas é a chave e as linhas hifenizadas definem uma lista de frutas.

YAML também oferece suporte a estruturas aninhadas, permitindo que você represente hierarquias de dados complexas:

pessoa:
nome:JohnCorça
idade:30
endereço:
rua:123PrincipalSt
cidade:qualquer cidade
país:EUA

O pessoa key contém outro conjunto de pares chave-valor, formando uma estrutura aninhada. O endereço key tem seu próprio conjunto de pares chave-valor.

Trabalhando com YAML em Go

O Go não fornece funcionalidade integrada para arquivos YAML, mas existem pacotes de terceiros que fornecem.

O yaml pacote é um pacote popular para trabalhar com arquivos YAML. Ele fornece:

• Recursos de análise e serialização.
• Suporte para tags YAML.
• Conformidade abrangente com as especificações YAML.
• Controle refinado sobre empacotamento e desempacotamento.
• Manipulação de erros.
• Compatibilidade com várias versões YAML.

Abra seu terminal e execute este comando para instalar o pacote YAML para seu projeto:

# instale a versão 3 do pacote yaml
acesse gopkg.in/yaml.v3

Depois de instalar o pacote, você pode usar o importar para importar o pacote para seus arquivos Go.

importar"gopkg.in/yaml.v3"

Você pode escolher várias versões YAML com base na versão da especificação YAML que deseja usar.

Lendo e analisando estruturas de dados YAML to Go

Uma tarefa essencial que você deseja realizar é analisar estruturas de dados YAML to Go. O yaml O pacote fornece uma API simples e conveniente para fazer isso.

Considere estes dados YAML:

# output.yaml
pessoa:
nome:JohnCorça
idade:30
e-mail:[email protected]

Você pode definir uma estrutura correspondente com nomes de campo correspondentes para analisar os dados YAML em uma estrutura de dados Go com o yaml pacote.

// A estrutura da pessoa representa a chave da pessoa em YAML.
tipo Pessoa estrutura {
 Nome corda`yaml:"nome"`
 Idade int`yaml:"idade"`
 E-mail corda`yaml:"e-mail"`
}

O yaml As tags struct ajudam a mapear as chaves YAML para os campos struct durante a operação de análise.

Veja como você pode analisar os dados YAML em uma estrutura de dados Go:

importar (
"fmt"
"gopkg.in/yaml.v3"
"os"
)
funçãoprincipal() {
// lê o arquivo output.yaml 
 dados, erro := os. ReadFile("output.yaml")
se erro != nada {
pânico(errar)
 }

// cria uma estrutura de pessoa e desserializa os dados nessa estrutura
var pessoa pessoa
se err := yaml. Unmarshal (dados, &pessoa); erro != nada {
pânico(errar)
 }

// imprime os campos no console
 fmt. Imprimirf("Nome: %s\n", pessoa. Nome)
 fmt. Imprimirf("Idade: %d\n", pessoa. Idade)
 fmt. Imprimirf("E-mail: %s\n", pessoa. E-mail)
}

O principal função lê o output.yaml arquivo com o ioutil pacote de ReadFile função. Em seguida, ele cria uma instância do Pessoa struct e analisa os dados na struct com o Unmarshal método do yaml pacote. O principal a função imprime os campos da instância de struct; aqui está o resultado:

Inserindo dados em um arquivo YAML

Você pode usar estruturas de dados Go para inserir dados em arquivos YAML. Veja como você pode inserir dados em um arquivo YAML com uma instância do Pessoa estrutura:

funçãoprincipal() {
// Cria uma instância da estrutura Person com dados de amostra
 pessoa := Pessoa{
 Nome: "John Doe",
 Idade: 30,
 E-mail: "[email protected]",
 }
// Serializa a estrutura da pessoa no formato YAML
 dados, erro := yaml. Marechal(&pessoa)
se erro != nada {
pânico(errar)
 }
// Grava os dados YAML serializados em um arquivo chamado "output.yaml"
 erro = os. WriteFile("output.yaml", dados, 0644)
se erro != nada {
pânico(errar)
 }
 fmt. Imprimirln("Dados gravados em output.yaml")
}

O pessoa variável é uma instância do Pessoa tipo de estrutura. Use o Marechal método do yaml pacote para converter a estrutura em YAML. Ele pega a instância da struct e retorna a representação YAML e um erro.

Você pode usar o WriteFile função do os pacote para gravar os dados YAML em seu arquivo (neste caso, output.yaml).

Após uma serialização de dados YAML bem-sucedida e uma operação de gravação, o principal A função imprime uma mensagem para o console.

Você pode empacotar e desempacotar YAML em mapas como faz com structs.

Aqui está um exemplo de empacotamento e desempacotamento de dados YAML com mapas:

pacote principal
importar (
"fmt"
"gopkg.in/yaml.v3"
)
funçãoprincipal() {
// Dados para marshaling
 dados := mapa[corda]interface{}{
"nome": "John Doe",
"idade": 30,
"e-mail": "[email protected]",
 }
// Organizando os dados em YAML
 yamlData, erro := yaml. Marechal (dados)
se erro != nada {
 fmt. Imprimirln("Erro durante o empacotamento:", erro)
retornar
 }
 fmt. Imprimirln("Dados YAML organizados:")
 fmt. Imprimirln(corda(yamlData))
// Desempacotando os dados YAML em um mapa
var dados unmarshalled mapa[corda]interface{}
 erro = yaml. Unmarshal (yamlData, &unmarshalledData)
se erro != nada {
 fmt. Imprimirln("Erro durante a desempacotamento:", erro)
retornar
 }
 fmt. Imprimirln("\nDados descompactados:")
 fmt. Println (unmarshalledData)
}

O processo é o mesmo que para tipos de estrutura, exceto que você está usando mapas para a representação de dados. O Unmarshal e Marechal funcionam para ambos os tipos de dados.

Docker Compose usa arquivos YAML para configuração

Trabalhar com arquivos YAML em Go fornece uma abordagem poderosa e flexível para gerenciar dados de configuração.

Um caso de uso proeminente para arquivos YAML é o Docker Compose, em que um arquivo YAML serve como configuração para definir e gerenciar aplicativos Docker de vários contêineres.

O Docker Compose aproveita a simplicidade e a legibilidade do YAML para definir serviços, redes, volumes e outros componentes de aplicativos em contêineres para facilitar a orquestração de contêineres.