Aller au contenu
🛠️ToolsShed

Kubernetes YAML Generator

Générer les manifests Kubernetes pour Deployments, Services, ConfigMaps et Namespaces.

Configuration de déploiement

deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  namespace: default
  labels:
    app: my-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app
          image: nginx:latest
          ports:
            - containerPort: 80
        env:
          - name: ENV
            value: "production"
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 500m
              memory: 512Mi

Appliquer avec : kubectl apply -f deployment.yaml

À propos de cet outil

Kubernetes YAML Generator est un outil destiné aux développeurs qui convertit les définitions manuelles de manifestes Kubernetes en fichiers de configuration YAML correctement formatés. Que vous déploiez des applications containerisées, gériez des microservices ou configuriez l'infrastructure as code, cet outil élimine la tâche fastidieuse d'écrire manuellement du YAML Kubernetes en générant des manifestes propres et syntaxiquement valides pour Deployments, Services, ConfigMaps et Namespaces. Il garantit que vos configurations respectent les spécifications de l'API Kubernetes et les meilleures pratiques.

Pour utiliser l'outil, remplissez le formulaire de configuration avec les détails de vos ressources—spécifiez les métadonnées de déploiement, les images de conteneur, les ports de service, les variables d'environnement et d'autres paramètres. Le générateur produit automatiquement du YAML correctement indenté et bien structuré qui est prêt à être appliqué directement à votre cluster Kubernetes en utilisant kubectl ou votre pipeline CI/CD. Vous pouvez personnaliser les noms de ressources, les étiquettes, les sélecteurs et tous les autres champs avant la génération.

Cet outil est particulièrement précieux pour les ingénieurs DevOps, les développeurs d'applications et les équipes d'infrastructure qui travaillent avec Kubernetes. Il gère les cas limites courants tels que les mappages de ports, volumeMounts, securityContext et limites de ressources, ce qui permet d'économiser du temps et de réduire les erreurs de syntaxe YAML qui pourraient empêcher des déploiements réussis.

Questions Fréquentes

Implémentation du Code

import subprocess
import yaml
import tempfile
import os

def generate_deployment(name, image, replicas=2, port=80, namespace="default"):
    """Generate a Kubernetes Deployment manifest dict."""
    return {
        "apiVersion": "apps/v1",
        "kind": "Deployment",
        "metadata": {"name": name, "namespace": namespace},
        "spec": {
            "replicas": replicas,
            "selector": {"matchLabels": {"app": name}},
            "template": {
                "metadata": {"labels": {"app": name}},
                "spec": {
                    "containers": [{
                        "name": name,
                        "image": image,
                        "ports": [{"containerPort": port}]
                    }]
                }
            }
        }
    }

manifest = generate_deployment("my-app", "nginx:latest", replicas=3)
yaml_str = yaml.dump(manifest, default_flow_style=False)
print(yaml_str)

# Apply using kubectl
with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
    f.write(yaml_str)
    tmp = f.name

result = subprocess.run(["kubectl", "apply", "-f", tmp], capture_output=True, text=True)
print(result.stdout)
os.unlink(tmp)

Comments & Feedback

Comments are powered by Giscus. Sign in with GitHub to leave a comment.