Formateur et validateur YAML (YML)

Qu'est-ce que le formateur YAML/YML ?

YAML (YAML Ain't Markup Language) est un format lisible utilisé pour les configurations d'applications, CI/CD, Docker Compose et les définitions d'API. Cet outil formate, valide et compacte YAML ou YML dans le navigateur sans envoyer le contenu.

Comment l'utiliser

1. Collez YAML ou YML dans l'éditeur.
2. Choisissez une indentation de deux ou quatre espaces et la largeur de ligne.
3. Sélectionnez Formater YAML, Compacter YAML ou Valider.
4. Copiez le résultat ou téléchargez-le au format .yaml.

Cas d'usage courants

• Uniformiser le style avant publication
• Repérer des problèmes de structure ou de syntaxe
• Présenter des extraits propres dans la doc

✨ Caractéristiques Clés

• 🎯 Validation de Format : Vérifie les erreurs de syntaxe YAML et fournit des suggestions détaillées
• 🎨 Embellissement de Format : Formate automatiquement le contenu YAML avec indentation et format
• 🗜️ Compression de Contenu : Supprime les espaces et commentaires inutiles pour compresser la taille du fichier
• 📋 Copie en Un Clic : Les résultats de format peuvent être copiés directement pour utilisation
• 🔧 Localisation d'Erreurs : Localise avec précision la position des erreurs de syntaxe
• 💾 Téléchargement YAML : Enregistre le résultat formaté dans un fichier .yaml

📖 Exemples d'Utilisation

Exemple de Formatage

YAML Original :

name:ToolMi
version:1.0.0
features:
- format
- validate
- compress
config:
  debug:true
  port:3000

Après Formatage :

name: ToolMi
version: 1.0.0
features:
  - format
  - validate
  - compress
config:
  debug: true
  port: 3000

Exemple de Structure Complexe

YAML d'Entrée :

database:
  host: localhost
  port: 5432
  credentials:
    username: admin
    password: secret
  pools:
    - name: read_pool
      size: 10
    - name: write_pool
      size: 5

Après Validation et Embellissement :

database:
  host: localhost
  port: 5432
  credentials:
    username: admin
    password: secret
  pools:
    - name: read_pool
      size: 10
    - name: write_pool
      size: 5

🎯 Scénarios d'Application

1. Formatage des fichiers de configuration YAML (YML) des applications

Organiser et valider les fichiers de configuration d'applications :

# Fichier de configuration d'application (config.yml)
app:
  name: ToolMi
  version: 1.0.0
  environment: production
  
server:
  host: 0.0.0.0
  port: 3000
  ssl:
    enabled: true
    cert_path: /etc/ssl/certs/app.crt
    key_path: /etc/ssl/private/app.key
    
database:
  type: postgresql
  host: localhost
  port: 5432
  name: toolmi_db
  username: ${DB_USER}
  password: ${DB_PASSWORD}
  pool:
    min_connections: 2
    max_connections: 10
    
redis:
  host: localhost
  port: 6379
  password: ${REDIS_PASSWORD}
  db: 0
  
logging:
  level: info
  format: json
  outputs:
    - type: file
      path: /var/log/app.log
    - type: console

2. Formatage YAML (YML) des configurations Docker Compose

Gérer la configuration d'orchestration de conteneurs Docker :

# docker-compose.yml
version: '3.8'

services:
  web:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DB_HOST=database
    depends_on:
      - database
      - redis
    volumes:
      - ./uploads:/app/uploads
    networks:
      - app-network
      
  database:
    image: postgres:13
    environment:
      POSTGRES_DB: toolmi_db
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - app-network
      
  redis:
    image: redis:6-alpine
    command: redis-server --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis_data:/data
    networks:
      - app-network

volumes:
  postgres_data:
  redis_data:

networks:
  app-network:
    driver: bridge

3. Formatage YAML (YML) des pipelines CI/CD

Configuration de flux de travail GitHub Actions :

# .github/workflows/deploy.yml
name: Déploiement en Production

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  NODE_VERSION: '18'
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - name: Checkout du code
        uses: actions/checkout@v3
        
      - name: Configurer Node.js
        uses: actions/setup-node@v3
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'
          
      - name: Installer les dépendances
        run: npm ci
        
      - name: Exécuter les tests
        run: npm test
        
      - name: Exécuter le linting
        run: npm run lint
        
  build:
    needs: test
    runs-on: ubuntu-latest
    
    steps:
      - name: Checkout du code
        uses: actions/checkout@v3
        
      - name: Construire l'image Docker
        run: |
          docker build -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest .
          
      - name: Push vers le registre
        run: |
          echo ${{ secrets.GITHUB_TOKEN }} | docker login ${{ env.REGISTRY }} -u ${{ github.actor }} --password-stdin
          docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest

4. Formatage des manifestes Kubernetes en YAML (YML)

Fichiers de configuration de déploiement Kubernetes :

# deployment.yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: toolmi-app
  labels:
    app: toolmi
spec:
  replicas: 3
  selector:
    matchLabels:
      app: toolmi
  template:
    metadata:
      labels:
        app: toolmi
    spec:
      containers:
        - name: app
          image: toolmi/app:latest
          ports:
            - containerPort: 3000
          env:
            - name: NODE_ENV
              value: "production"
            - name: DB_HOST
              valueFrom:
                secretKeyRef:
                  name: app-secrets
                  key: db-host
          resources:
            requests:
              memory: "256Mi"
              cpu: "250m"
            limits:
              memory: "512Mi"
              cpu: "500m"
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /ready
              port: 3000
            initialDelaySeconds: 5
            periodSeconds: 5

---
apiVersion: v1
kind: Service
metadata:
  name: toolmi-service
spec:
  selector:
    app: toolmi
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: LoadBalancer

🔧 Détails Techniques

Règles de Syntaxe YAML

Règles de base de syntaxe YAML :

Règles d'Indentation :

• Utiliser des espaces pour l'indentation, les tabulations ne sont pas autorisées
• Les éléments du même niveau doivent être alignés à gauche
• Les éléments enfants doivent être plus indentés que les éléments parents

Types de Données :

• Chaînes : Peuvent ne pas avoir de guillemets, les caractères spéciaux nécessitent des guillemets
• Nombres : Entiers et nombres à virgule flottante
• Booléens : true/false, yes/no, on/off
• Valeurs null : null, ~, ou vide

Types de Collection :

• Tableaux : Utiliser - pour indiquer les éléments de liste
• Objets : Utiliser key: value pour représenter les paires clé-valeur
• Imbrication : Prend en charge les structures imbriquées de niveaux arbitraires

Erreurs Communes

Erreurs communes que le formateur YAML peut détecter :

Erreurs d'Indentation :

# Mauvais exemple
config:
  debug: true
 port: 3000  # Indentation inconsistente

# Bon exemple
config:
  debug: true
  port: 3000

Problèmes de Guillemets :

# Mauvais exemple
message: It's a test  # Guillemet simple non échappé

# Bon exemple
message: "It's a test"
# ou
message: 'It''s a test'

Format de Liste :

# Mauvais exemple
features:
- format
 - validate  # Erreur d'indentation

# Bon exemple
features:
  - format
  - validate

💡 Conseils d'Utilisation

• Indentation Cohérente : Toujours utiliser le même nombre d'espaces pour l'indentation (2 espaces recommandés)
• Usage de Guillemets : Entourer les chaînes contenant des caractères spéciaux avec des guillemets
• Normes de Commentaires : Utiliser # pour ajouter des commentaires, ajouter un espace avant les commentaires
• Chaînes Multilignes : Utiliser | ou > pour gérer le texte multiligne

⚠️ Notes Importantes

• Interdiction de Tabulations : YAML n'autorise pas les tabulations, seuls les espaces peuvent être utilisés
• Sensible à l'Indentation : Les erreurs d'indentation causeront des échecs d'analyse
• Caractères Spéciaux : Les deux-points, guillemets et autres caractères spéciaux nécessitent une gestion appropriée
• Format d'Encodage : Assurer que les fichiers utilisent l'encodage UTF-8

🚀 Comment Commencer

1. Saisie YAML : Collez le contenu YAML à traiter dans la zone de saisie
2. Sélection d'Opération : Cliquez sur les boutons "Formater", "Valider" ou "Compresser"
3. Vérification des Résultats : Vérifiez le YAML traité dans la zone de sortie
4. Copie ou Téléchargement : Copiez le résultat ou enregistrez-le sous formatted.yaml
5. Correction d'Erreurs : Corrigez les problèmes de syntaxe basés sur les suggestions d'erreur

Conseil : Cet outil traite localement côté client et ne télécharge pas le contenu YAML vers le serveur, garantissant la sécurité des données.

❓ FAQ

Q1 : Pourquoi le résultat est incorrect ?
R : Vérifiez le format d'entrée et les options, puis essayez l'exemple s'il existe.

Q2 : Et si l'entrée est très grande ?
R : Découpez les données en plus petits blocs pour plus de stabilité.

Q3 : Comment sauvegarder la sortie ?
R : Cliquez sur le bouton de téléchargement pour enregistrer directement formatted.yaml.