kubric-cli 0.1.1
Pythonic Kubernetes DSL — as powerful as Helm, as easy as Pulumi, with the readability of contextlib.
Requires Python: >=3.11

# kubric

Pythonic Kubernetes DSL — as powerful as Helm, as easy as Pulumi, with the readability of contextlib.

```python
with Deployment("api", replicas=3):
    with Container("api", image="myorg/api:v2"):
        Port(8080)
        EnvVar("DB_HOST", "postgresql")
        Resources(cpu="250m", memory="256Mi")
        Probe("readiness", http_get={"path": "/health", "port": 8080})
    Service(port=8080)
```

## Installation

```bash
pip install kubric
```

## Quick Start

### Deploy with CLI

```bash
# Single chart
tkubric up postgresql
kubric up postgresql --set replicas=3 --set storage=50Gi
kubric up postgresql -f values.yaml

# With stack file
kubric up -f stack.yaml
kubric up -f stack.yaml -f values.prod.yaml

# YAML preview (without apply)
kubric template postgresql --set metrics.enabled=true
```

### Stack file

```yaml
# stack.yaml
apiVersion: kubric.io/v1
kind: Stack
metadata:
  name: my-project
  namespace: my-project

components:
  - chart: postgresql
    name: db
    values:
      database: myapp
      storage: 50Gi

  - chart: redis
    name: cache
    values:
      storage: 5Gi

  - chart: redmine
    name: redmine
    values:
      postgresql:
        enabled: false
        name: "${db.host}"
```

### Environment overlay

```yaml
# values.prod.yaml
components:
  db:
    values:
      replicas: 3
      storage: 200Gi
  redmine:
    values:
      replicas: 5
      ingress:
        enabled: true
        host: redmine.example.com
        tls: true
```

```bash
kubric up -f stack.yaml -f values.prod.yaml
```

## Three Usage Layers

### Layer 1: CLI one-liner

```bash
kubric up postgresql --set storage=50Gi
```

### Layer 2: YAML Stack

Declarative component architecture without Python knowledge:

```bash
kubric up -f stack.yaml -f values.prod.yaml --set components.db.values.replicas=5
```

### Layer 3: Python Chart Development

Chart authors define reusable components with contextlib:

```python
from contextlib import contextmanager
from kubric.chart.base import Chart
from kubric.core.resources import *

@contextmanager
def my_container(name, image, port=8080):
    with Container(name, image=image):
        Port(port, name="http")
        Probe("readiness", http_get={"path": "/health", "port": port})
        yield  # can be extended inside the with block

class MyChart(Chart):
    name = "myapp"
    version = "1.0.0"

    def render(self, values):
        with Deployment(values["name"], replicas=values.get("replicas", 1)):
            with my_container(values["name"], values["image"]):
                EnvVar("DB_HOST", values.get("db_host", "localhost"))
            Service(port=8080)
```

## Resource Reference

### with (context manager) — can have children

```python
with Deployment("api", replicas=3):          # Pod spec parent
    with Container("api", image="app:v1"):   # Leaf parent
        ...
    with Service(type="NodePort"):           # Multi-port mode
        ServicePort(80, name="http")
        ServicePort(443, name="https")

with StatefulSet("db", replicas=3):          # StatefulSet
    ...

with ConfigMap("cfg"):                       # Key-value store
    Data("key", "value")

with Secret("creds"):                        # Encoded data
    Data("password", "s3cret")

with Ingress("ing", host="app.example.com"): # Parametric
    IngressRule("/", "web", 80)
    IngressRule("/api", "api", 8080)

with CronJob("backup", schedule="0 2 * * *"):
    with Container("backup", image="backup:v1"):
        ...
```

### Leaf — cannot have children, plain call

```python
Port(8080, name="http")
EnvVar("DB_HOST", "localhost")
EnvVar("PASSWORD", secret_ref="my-secret", secret_key="pass")
Resources(cpu="250m", memory="256Mi", limits_cpu="500m", limits_memory="512Mi")
VolumeMount("/data", "my-vol", read_only=True)
Probe("liveness", http_get={"path": "/health", "port": 8080})
Service(port=80)                              # Simple mode (leaf)
Data("key", "value")                          # Inside ConfigMap/Secret
IngressRule("/", "web", 80)                   # Inside Ingress
PersistentVolumeClaim("data", size="50Gi")
EmptyDirVolume("tmp")
ConfigMapVolume("cfg", "my-config")
SecretVolume("certs", "tls-certs")
```

## Chart Development

Each chart is a pip package:

```
kubric-myapp/
├── pyproject.toml
├── src/kubric_myapp/
│   ├── __init__.py      # MyChart class
│   └── defaults.yaml    # Default values
```

```toml
# pyproject.toml
[project]
name = "kubric-myapp"
version = "1.0.0"
dependencies = ["kubric>=0.1.0"]

[project.entry-points."kubric.charts"]
myapp = "kubric_myapp:MyChart"
```

### Dependency

```toml
# kubric-redmine/pyproject.toml
dependencies = [
    "kubric>=0.1.0",
    "kubric-postgresql>=16.0.0",
]
```

```python
from kubric.chart.dependency import ChartDep

class RedmineChart(Chart):
    requires = [
        ChartDep("postgresql", deploy=True, condition="postgresql.enabled"),
    ]
```

## CLI Commands

```bash
kubric up <chart> [flags]       # Deploy
kubric template <chart> [flags] # YAML preview
kubric list                     # List installed charts
kubric inspect <chart>          # Chart details + defaults
```

### Flags

| Flag | Description |
|------|-------------|
| `-f <file>` | Values or stack file (multiple allowed) |
| `--set key=val` | Value override |
| `-n <namespace>` | Kubernetes namespace |
| `--create-namespace` | Create namespace if not exists |
| `--dry-run` | kubectl dry-run |
| `-o <file>` | Output file (template) |

### Value precedence

```
defaults.yaml → -f values.yaml → -f values.prod.yaml → --set key=val
```

## License

MIT