k8s-deploy-helper 0.1.1

package/README.md

@@ -0,0 +1 @@
+## K8s-deploy-helper

package/bin/cli.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { runDeploy } from '../src/index.js';
+
+const program = new Command();
+
+program
+  .name('k8s-deploy')
+  .description('Build and deploy apps to Kubernetes')
+  .version('0.1.0');
+
+program
+  .command('deploy')
+  .description('Build Docker image and deploy to Kubernetes')
+  .option('-c, --config <path>', 'Config file path', 'k8s.config.json')
+  .action(runDeploy);
+
+program.parse();

package/k8s.config.json

@@ -0,0 +1,33 @@
+{
+  "appName": "my-app",
+  "namespace": "default",
+
+  "docker": {
+    "image": "lucky/my-app",
+    "tag": "latest",
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+
+  "kubernetes": {
+    "replicas": 2,
+    "containerPort": 3000,
+    "servicePort": 80,
+    "serviceType": "ClusterIP"
+  },
+
+  "resources": {
+    "limits": {
+      "cpu": "500m",
+      "memory": "512Mi"
+    },
+    "requests": {
+      "cpu": "250m",
+      "memory": "256Mi"
+    }
+  },
+
+  "env": {
+    "NODE_ENV": "production"
+  }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "k8s-deploy-helper",
+  "version": "0.1.1",
+  "description": "CLI tool to build, push and deploy applications to Kubernetes",
+  "type": "module",
+  "bin": {
+    "k8s-deploy": "bin/cli.js"
+  },
+  "scripts": {
+    "dev": "node ./bin/cli.js",
+    "lint": "eslint .",
+    "release": "npm publish"
+  },
+  "keywords": [
+    "kubernetes",
+    "devops",
+    "docker",
+    "ci-cd",
+    "deployment",
+    "helm"
+  ],
+  "author": "Lokesh Shimpi",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^14.0.2",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3",
+    "js-yaml": "^4.1.1"
+  }
+}

package/src/config/loadConfig.js

@@ -0,0 +1,15 @@
+import fs from 'fs';
+import path from 'path';
+
+export function loadConfig(configPath) {
+  const absolutePath = path.resolve(process.cwd(), configPath);
+
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Config file not found: ${absolutePath}`);
+  }
+
+  const raw = fs.readFileSync(absolutePath, 'utf-8');
+  const config = JSON.parse(raw);
+
+  return config;
+}

package/src/config/validateConfig.js

@@ -0,0 +1,13 @@
+export function validateConfig(config) {
+  if (!config.appName) {
+    throw new Error('appName is required in config');
+  }
+
+  if (!config.docker?.image) {
+    throw new Error('docker.image is required');
+  }
+
+  if (!config.kubernetes?.containerPort) {
+    throw new Error('kubernetes.containerPort is required');
+  }
+}

package/src/docker/buildPush.js

@@ -0,0 +1,28 @@
+import { execa } from 'execa';
+import fs from 'fs';
+
+export async function buildAndPushImage(config) {
+  const { image, tag, context, dockerfile } = config.docker;
+
+  const dockerfilePath = dockerfile || 'Dockerfile';
+
+  if (!fs.existsSync(dockerfilePath)) {
+    throw new Error(`Dockerfile not found at path: ${dockerfilePath}`);
+  }
+
+  const fullImageName = `${image}:${tag}`;
+
+  console.log(`\n🐳 Building Docker image: ${fullImageName}`);
+
+  await execa(
+    'docker',
+    ['build', '-t', fullImageName, '-f', dockerfilePath, context || '.'],
+    { stdio: 'inherit' }
+  );
+
+  console.log(`\n📤 Pushing Docker image: ${fullImageName}`);
+
+  await execa('docker', ['push', fullImageName], { stdio: 'inherit' });
+
+  return fullImageName;
+}

package/src/index.js

@@ -0,0 +1,27 @@
+import { loadConfig } from './config/loadConfig.js';
+import { validateConfig } from './config/validateConfig.js';
+import { buildAndPushImage } from './docker/buildPush.js';
+import { generateDeployment } from './k8s/deployment.js';
+import { generateService } from './k8s/service.js';
+import { applyKubernetes } from './k8s/apply.js';
+
+export async function runDeploy(options) {
+  console.log('Loading config...');
+  const config = loadConfig(options.config);
+  validateConfig(config);
+
+  console.log(`App: ${config.appName}`);
+
+  let image = `${config.docker.image}:${config.docker.tag}`;
+
+  try {
+    image = await buildAndPushImage(config);
+  } catch {
+    console.warn('\n⚠️ Image push failed — continuing deployment');
+  }
+
+  generateDeployment(config, image);
+  generateService(config);
+
+  await applyKubernetes(config);
+}

package/src/k8s/apply.js

@@ -0,0 +1,32 @@
+import { execa } from 'execa';
+
+export async function applyKubernetes(config) {
+  const namespace = config.namespace || 'default';
+
+  console.log(`\n☸️  Deploying to Kubernetes namespace: ${namespace}`);
+
+  // Ensure namespace exists (idempotent)
+  await execa(
+    'kubectl',
+    ['create', 'namespace', namespace],
+    { stdio: 'ignore' }
+  ).catch(() => {
+    // Namespace already exists — ignore
+  });
+
+  console.log('📦 Applying deployment.yaml');
+  await execa(
+    'kubectl',
+    ['apply', '-f', 'deployment.yaml', '-n', namespace],
+    { stdio: 'inherit' }
+  );
+
+  console.log('📦 Applying service.yaml');
+  await execa(
+    'kubectl',
+    ['apply', '-f', 'service.yaml', '-n', namespace],
+    { stdio: 'inherit' }
+  );
+
+  console.log('\n✅ Kubernetes resources applied successfully');
+}

package/src/k8s/deployment.js

@@ -0,0 +1,50 @@
+import yaml from 'js-yaml';
+import fs from 'fs';
+
+export function generateDeployment(config, image) {
+  const deployment = {
+    apiVersion: 'apps/v1',
+    kind: 'Deployment',
+    metadata: {
+      name: config.appName,
+      namespace: config.namespace || 'default'
+    },
+    spec: {
+      replicas: config.kubernetes.replicas,
+      selector: {
+        matchLabels: {
+          app: config.appName
+        }
+      },
+      template: {
+        metadata: {
+          labels: {
+            app: config.appName
+          }
+        },
+        spec: {
+          containers: [
+            {
+              name: config.appName,
+              image,
+              ports: [
+                {
+                  containerPort: config.kubernetes.containerPort
+                }
+              ],
+              env: Object.entries(config.env || {}).map(
+                ([key, value]) => ({ name: key, value })
+              ),
+              resources: config.resources
+            }
+          ]
+        }
+      }
+    }
+  };
+
+  const yamlContent = yaml.dump(deployment);
+  fs.writeFileSync('deployment.yaml', yamlContent);
+
+  return 'deployment.yaml';
+}

package/src/k8s/service.js

@@ -0,0 +1,30 @@
+import yaml from 'js-yaml';
+import fs from 'fs';
+
+export function generateService(config) {
+  const service = {
+    apiVersion: 'v1',
+    kind: 'Service',
+    metadata: {
+      name: config.appName,
+      namespace: config.namespace || 'default'
+    },
+    spec: {
+      type: config.kubernetes.serviceType,
+      selector: {
+        app: config.appName
+      },
+      ports: [
+        {
+          port: config.kubernetes.servicePort,
+          targetPort: config.kubernetes.containerPort
+        }
+      ]
+    }
+  };
+
+  const yamlContent = yaml.dump(service);
+  fs.writeFileSync('service.yaml', yamlContent);
+
+  return 'service.yaml';
+}