Deploying with Jeet CLI: From Project to Managed Cluster in Minutes

What You’ll Get With a Single Command

Jeet’s jeet deploy command packages your local application directory into a container image and pushes it to the Jeet platform, where it is automatically scheduled on a managed cluster. No Dockerfiles, no manual CI pipelines, just a jeet.yaml (or environment variables) to tweak ports, memory, and secrets.

How the Deployment Flow Works

The CLI follows a predictable pipeline:

1. Source Packaging – Jeet zips the current working directory, respecting a .jeetignore (similar to .gitignore) to exclude unnecessary files.
2. Runtime Detection – A buildpack engine scans the package for markers (e.g., package.json, requirements.txt) to decide whether the app is Node.js, Python, Go, etc.
3. Image Build – The detected buildpack generates a Dockerfile, builds a container image, and tags it with the project name and a timestamp.
4. Push & Deploy – The image is pushed to Jeet’s internal registry. The platform then creates a deployment manifest that includes resource limits and environment variables from jeet.yaml or the CLI flags.
5. Cluster Rollout – Jeet’s managed Kubernetes cluster pulls the image, schedules it on a node, and exposes the service via a load‑balanced ingress.

Example: Deploying a Simple Node.js App

Assume the following directory layout:

myapp/
├─ index.js
├─ package.json
└─ jeet.yaml

Contents of jeet.yaml:

name: myapp
env: production
port: 8080
resources:
  memory: 512Mi
  cpu: 0.5
secrets:
  DB_PASSWORD: ${{secrets.DB_PASSWORD}}

Deploy with a single command:

# Run as a user with Jeet CLI credentials
jeet deploy --env=production

Key checks after the command completes:

• Verify the deployment status: jeet status myapp – should show Running and the cluster IP.
• Test the endpoint: curl http://{cluster-ip}:8080/health – expect a 200 OK.
• Inspect logs: jeet logs myapp --tail 20 – should contain the app’s startup message.

Limits and Common Pitfalls

Runtime Detection Can Fail

Jeet relies on standard manifest files. If package.json is missing, moved, or malformed, the buildpack will default to a generic Node.js image or fail outright. Always keep the manifest in the project root.

Large Directories Slow Uploads

Without a proper .jeetignore, the CLI uploads the entire repository, including build artifacts, tests, and local config files. A typical .jeetignore looks like:

node_modules/
.git/
*.log
coverage/

Resource Limits May Cause OOM Kills

Under‑estimating memory or cpu in jeet.yaml can lead to the container being terminated by the kernel. Start with the defaults (512Mi, 0.5 CPU) and adjust after profiling the app’s actual usage.

Secrets Not Injected Correctly

Secrets must be defined in Jeet’s secret store and referenced with the ${{secrets.NAME}} syntax. If the secret is missing, the deployment will succeed but the app may crash at runtime due to missing environment variables.

Overriding Ports Improperly

Jeet exposes the container port defined in jeet.yaml. If you set port: 80 but the app listens on 3000, the ingress will forward traffic to the wrong port, resulting in connection timeouts.

Practical Verification Checklist

• Run jeet deploy --dry-run to preview the buildpack detection and container tags.
• After deployment, use jeet status --watch to monitor rollout progress.
• Confirm the service is reachable: curl -I http://{cluster-ip}:{port} – should return 200 OK.
• Check resource usage: jeet metrics myapp – verify memory and CPU stay within limits.

When to Roll Back

If the deployment fails or the app crashes, you can revert to the previous stable version with:

jeet rollback myapp

This command restores the last successful container image and re‑rolls it to the cluster, minimizing downtime.