🧠FFVAcademy
📄

JSON, YAML e variáveis de ambiente: config moderna

8 min de leitura·+40 XP
Pré-requisitos (0/1)0%

Recomendamos completar os pré-requisitos antes de seguir, mas nada te impede de continuar.

JSON e YAML são os dois formatos de dados estruturados mais usados em software moderno. Variáveis de ambiente são o padrão para configuração de aplicações. Dominar os três é pré-requisito para trabalhar com qualquer infraestrutura ou API.

JSON: o formato universal de dados

JSON (JavaScript Object Notation) é o formato de troca de dados da web. Leve, legível por humanos, suportado por todas as linguagens. Tem apenas 6 tipos de valor.

{
  "nome": "Fernando",
  "idade": 32,
  "ativo": true,
  "endereco": null,
  "tags": ["dev", "backend", "cloud"],
  "config": {
    "timeout": 30,
    "retries": 3
  }
}

// Os 6 tipos JSON:
// string   → "texto entre aspas duplas" (nunca simples)
// number   → 42, 3.14, -1, 1e10 (sem distinção int/float)
// boolean  → true, false (minúsculas)
// null     → null
// array    → [1, "dois", true, null]
// object   → {"chave": "valor"}

// Erros comuns:
// ❌ {name: 'Fernando'}    → chaves devem ser strings com aspas duplas
// ❌ {color: #fff}         → strings precisam de aspas duplas
// ❌ [1, 2, 3,]            → trailing comma não é permitido
// ❌ // comentário         → JSON não suporta comentários
# Trabalhar com JSON na linha de comando:
# jq — processador de JSON poderoso
echo '{"name": "Fernando", "xp": 500}' | jq '.name'
# → "Fernando"

cat dados.json | jq '.users[] | select(.active == true) | .email'
cat dados.json | jq 'keys'                    # lista as chaves
cat dados.json | jq '. | length'              # tamanho do objeto/array
cat dados.json | jq '{nome: .name, xp}'      # transforma o objeto

# Python one-liner para formatar JSON bagunçado:
echo '{"a":1,"b":2}' | python3 -m json.tool
# → formatado com indentação

YAML: configuração legível por humanos

YAML (YAML Ain't Markup Language) é um superset de JSON otimizado para ser escrito e lido por humanos. É o formato padrão de Docker Compose, Kubernetes, GitHub Actions, Ansible e muitas outras ferramentas de infra.

# YAML equivalente ao JSON acima:
nome: Fernando
idade: 32
ativo: true
endereco: null        # ou ~
tags:
  - dev
  - backend
  - cloud
config:
  timeout: 30
  retries: 3

# Comentários são suportados (diferente de JSON!)
# debug: false   # desabilitado em produção

# Strings: aspas opcionais para simples, obrigatórias com caracteres especiais
titulo: Meu Projeto               # sem aspas
descricao: "Usa : e # na frase"   # aspas necessárias
url: 'https://exemplo.com/path'   # aspas simples também funcionam

# Strings multiline (muito útil em scripts CI/CD)
script: |
  npm install
  npm run build
  npm run test
# → preserva newlines exatamente como escrito

descricao: >
  Este é um texto longo que vai
  continuar na próxima linha.
# → junta as linhas com espaço (flow scalar)
# Gotchas do YAML:
# 1. Indentação é semântica (como Python) — só espaços, nunca tabs
# 2. Booleanos: yes/no/on/off também são true/false em YAML 1.1
#    (em YAML 1.2 / strictyaml, apenas true/false)
# 3. Números octais: 010 em YAML 1.1 = 8 (decimal) — use strings: "010"
# 4. Anchors e aliases — reutilização:
defaults: &defaults
  timeout: 30
  retries: 3

producao:
  <<: *defaults    # herda defaults
  timeout: 60      # sobrescreve timeout

# Validar YAML:
python3 -c "import yaml; yaml.safe_load(open('config.yaml'))"
# ou:
yamllint config.yaml   # ferramenta de linting

Variáveis de ambiente: o padrão 12-factor

O 12-factor app define que configuração deve vir de variáveis de ambiente — nunca hardcoded, nunca em arquivos commitados. Isso permite que o mesmo código rode em development, staging e produção apenas mudando as env vars.

# Configurar variáveis de ambiente no shell
export DATABASE_URL="postgresql://user:senha@localhost:5432/myapp"
export SECRET_KEY="s3cr3t-key-super-segura"
export DEBUG="false"
export PORT="8000"

# Variáveis só para um comando (não persiste no shell)
DATABASE_URL="..." PORT=8000 python manage.py runserver

# Ver todas as env vars do ambiente atual
env
printenv                      # idem
printenv DATABASE_URL         # ver uma variável específica
echo $DATABASE_URL            # idem

# Acessar em código:
# Python
import os
db_url = os.environ.get('DATABASE_URL')                  # None se não existir
db_url = os.environ['DATABASE_URL']                      # KeyError se não existir
db_url = os.getenv('DATABASE_URL', 'postgresql://...')   # com default

# Node.js
const dbUrl = process.env.DATABASE_URL;

# Go
dbUrl := os.Getenv("DATABASE_URL")

Arquivos .env: desenvolvimento local

# .env — carregado por dotenv, nunca commitado
DATABASE_URL=postgresql://user:senha@localhost:5432/myapp_dev
SECRET_KEY=dev-key-pode-ser-simples
DEBUG=true
PORT=3000
REDIS_URL=redis://localhost:6379

# .env.example — commitado, sem valores reais
DATABASE_URL=postgresql://user:senha@host:5432/dbname
SECRET_KEY=sua-chave-secreta-aqui
DEBUG=false
PORT=3000
REDIS_URL=redis://localhost:6379

# .gitignore — OBRIGATÓRIO
.env
.env.local
.env.*.local
*.env

# Carregar .env em Python (python-dotenv)
from dotenv import load_dotenv
load_dotenv()  # carrega .env para os.environ

# Node.js
require('dotenv').config()
# ou no package.json scripts: "dev": "node --env-file=.env server.js"

# Docker: passar env vars para container
docker run -e DATABASE_URL=postgresql://... myapp
docker run --env-file .env myapp           # carrega arquivo inteiro
⚠️
Hierarquia de segredos: para desenvolvimento, .env local é OK. Para produção, use um secrets manager: AWS Secrets Manager, GCP Secret Manager, HashiCorp Vault, ou Kubernetes Secrets. Nunca passe segredos como argumentos de linha de comando (ficam visíveis em ps aux).
AspectoJSONYAML
ComentáriosNão suportadoSuportado (#)
SintaxeExplícita (chaves, colchetes)Baseada em indentação
Multiline stringsLimitado (\n escape)Nativo (| e >)
Referências internasNãoSim (anchors & aliases)
Velocidade de parseMais rápidoMais lento
Uso principalAPIs, dados, config simplesConfig por humanos (k8s, CI/CD, Ansible)
Superset deJSON (todo JSON é YAML válido)
Regras práticas: use JSON para APIs e dados trocados entre sistemas. Use YAML para config de infra e ferramentas. Use variáveis de ambiente para segredos e config que muda entre ambientes. Nunca comite .env — sempre comite .env.example.
💡
Próximo: VSCode/Vim produtivos — os atalhos e configurações que mudam a velocidade de desenvolvimento.
🧩

Quiz rápido

3 perguntas · Acerte tudo e ganhe o badge 🎯 Gabarito

Continue lendo