# CLI ऑटोमेशन

{% hint style="success" %}
**पूर्वापेक्षाएँ:** SDK स्थापित करें (`pip install clore-ai`) और अपनी API कुंजी कॉन्फ़िगर करें। देखें [Python क्विकस्टार्ट](https://docs.clore.ai/guides/guides_v2-hi/getting-started/python-quickstart) यदि आपने अभी तक नहीं किया है।
{% endhint %}

## बुनियादी कार्यप्रवाह

कोर लूप: **खोज → तैनात → कनेक्ट → रद्द करें**.

```bash
# 1. एक GPU खोजें
clore search --gpu "RTX 4090" --max-price 2.0 --sort price --limit 5

# 2. तैनात करें (चरण 1 से एक सर्वर ID का उपयोग करें)
clore deploy 142 \
  --image cloreai/ubuntu22.04-cuda12 \
  --type on-demand \
  --currency bitcoin \
  --ssh-password MySecurePass \
  --port 22:tcp \
  --port 8888:http

# 3. अपने ऑर्डर जांचें
clore orders

# 4. सर्वर में SSH करें
clore ssh 38

# 5. समाप्त होने पर रद्द करें
clore cancel 38

# 6. वॉलेट बैलेंस जांचें
clore wallets
```

***

## CLI कमांड संदर्भ

| कमांड                                 | विवरण                                          |
| ------------------------------------- | ---------------------------------------------- |
| `clore search`                        | GPU मार्केटप्लेस खोजें                         |
| `clore deploy <server_id>`            | नया ऑर्डर बनाएं                                |
| `clore orders`                        | सक्रिय ऑर्डर सूचीबद्ध करें                     |
| `clore orders --completed`            | सभी ऑर्डर दिखाएँ जिनमें पूर्ण किए गए शामिल हैं |
| `clore ssh <order_id>`                | सक्रिय ऑर्डर में SSH करें                      |
| `clore cancel <order_id>`             | एक ऑर्डर रद्द करें                             |
| `clore wallets`                       | वॉलेट बैलेंस दिखाएँ                            |
| `clore servers`                       | आपके होस्ट किए गए सर्वरों को सूचीबद्ध करें     |
| `clore server-config <name>`          | सर्वर विन्यास दिखाएँ                           |
| `clore spot <server_id>`              | किसी सर्वर के लिए स्पॉट मार्केट देखें          |
| `clore spot-price <order_id> <price>` | एक ऑर्डर के लिए स्पॉट कीमत सेट करें            |
| `clore config set <key> <value>`      | कॉन्फ़िग मान सेट करें                          |
| `clore config get <key>`              | कॉन्फ़िग मान प्राप्त करें                      |
| `clore config show`                   | सभी कॉन्फ़िग दिखाएँ                            |

***

## CLI के साथ स्क्रिप्टिंग

### तैनात करें और SSH के लिए प्रतीक्षा करें

```bash
#!/bin/bash
# deploy-and-connect.sh — एक सर्वर तैनात करें और तैयार होने पर SSH करें

set -euo pipefail

SERVER_ID=${1:?Usage: $0 <server_id>}
IMAGE=${2:-cloreai/ubuntu22.04-cuda12}
PASSWORD="AutoDeploy$(date +%s)"

echo "🚀 सर्वर $SERVER_ID तैनात किया जा रहा है..."
clore deploy "$SERVER_ID" \
  --image "$IMAGE" \
  --type on-demand \
  --currency bitcoin \
  --ssh-password "$PASSWORD" \
  --port 22:tcp

echo "⏳ आदेश तैयार होने की प्रतीक्षा कर रहे हैं..."
sleep 15

echo "📦 सक्रिय ऑर्डर:"
clore orders

echo ""
echo "🔑 SSH पासवर्ड: $PASSWORD"
echo "💡 कनेक्ट करें: clore ssh <order_id>"
```

### सबसे सस्ता GPU खोजें और तैनात करें

```bash
#!/bin/bash
# cheapest-gpu.sh — मापदण्डों से मेल खाने वाला सबसे सस्ता GPU खोजें और तैनात करें

GPU_MODEL=${1:-"RTX 4090"}
MAX_PRICE=${2:-5.0}

echo "🔍 $GPU_MODEL के लिए \$$MAX_PRICE/घंटा से नीचे सबसे सस्ता खोज रहे हैं..."
clore search --gpu "$GPU_MODEL" --max-price "$MAX_PRICE" --sort price --limit 5

echo ""
read -p "तैनात करने के लिए सर्वर ID दर्ज करें (या बाहर निकलने के लिए 'q'): " SERVER_ID

if [ "$SERVER_ID" = "q" ]; then
    echo "रद्द किया गया."
    exit 0
fi

read -sp "SSH पासवर्ड: " SSH_PASS
echo ""

clore deploy "$SERVER_ID" \
  --image cloreai/ubuntu22.04-cuda12 \
  --type on-demand \
  --currency bitcoin \
  --ssh-password "$SSH_PASS" \
  --port 22:tcp \
  --port 8888:http

echo "✅ तैनात हो गया! स्थिति के लिए 'clore orders' जांचें."
```

### सभी ऑर्डर रद्द करें

```bash
#!/bin/bash
# cancel-all.sh — सभी सक्रिय ऑर्डर रद्द करें

echo "📦 वर्तमान ऑर्डर:"
clore orders

echo ""
read -p "क्या सभी सक्रिय ऑर्डर रद्द करें? (yes/no): " CONFIRM

if [ "$CONFIRM" = "yes" ]; then
    # चूंकि CLI एक बार में एक ऑर्डर रद्द करता है, इसलिए Python one-liner का उपयोग करें
    python3 -c "
from clore_ai import CloreAI
client = CloreAI()
orders = client.my_orders()
for o in orders:
    client.cancel_order(o.id, issue='Batch cleanup')
    print(f'Cancelled order {o.id}')
print(f'Done. Cancelled {len(orders)} orders.')
"
else
    echo "रद्द किया गया."
fi
```

***

## CI/CD एकीकरण

### GitHub Actions: प्रशिक्षण के लिए GPU तैनात करें

```yaml
# .github/workflows/train.yml
name: GPU Training

on:
  workflow_dispatch:
    inputs:
      gpu_model:
        description: 'GPU मॉडल'
        default: 'RTX 4090'
      max_price:
        description: 'अधिकतम कीमत USD/घंटा'
        default: '2.0'

env:
  CLORE_API_KEY: ${{ secrets.CLORE_API_KEY }}

jobs:
  train:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install clore-ai
        run: pip install clore-ai

      - name: Find and deploy GPU
        run: |
          python3 << 'EOF'
          import time, os
          from clore_ai import CloreAI

          client = CloreAI()

          # मेल खाने वाले सबसे सस्ते GPU को खोजें
          servers = client.marketplace(
              gpu="${{ github.event.inputs.gpu_model }}",
              max_price_usd=float("${{ github.event.inputs.max_price }}")
          )
          servers.sort(key=lambda s: s.price_usd or float("inf"))

          if not servers:
              print("कोई सर्वर उपलब्ध नहीं हैं!")
              exit(1)

          best = servers[0]
          print(f"सर्वर {best.id} पर तैनात कर रहे हैं: {best.gpu_model} @ ${best.price_usd:.4f}/घ")

          order = client.create_order(
              server_id=best.id,
              image="cloreai/ubuntu22.04-cuda12",
              type="on-demand",
              currency="bitcoin",
              ssh_password=os.environ.get("SSH_PASSWORD", "CITraining123"),
              ports={"22": "tcp"},
              command="bash /workspace/train.sh"
          )

          print(f"Order {order.id} created")

          # तैयार होने की प्रतीक्षा करें
          for _ in range(30):
              orders = client.my_orders()
              o = next((x for x in orders if x.id == order.id), None)
              if o and o.pub_cluster:
                  print(f"तैयार: {o.pub_cluster}")
                  break
              time.sleep(10)

          # क्लीनअप के लिए ऑर्डर ID सहेजें
          with open(os.environ["GITHUB_ENV"], "a") as f:
              f.write(f"ORDER_ID={order.id}\n")
          EOF

      - name: Wait for training to complete
        run: |
          echo "प्रशिक्षण प्रगति पर है..."
          # अपने मॉनिटरिंग लॉजिक यहाँ जोड़ें
          sleep 60

      - name: Cleanup GPU
        if: always()
        run: |
          python3 -c "
          from clore_ai import CloreAI
          import os
          client = CloreAI()
          order_id = int(os.environ.get('ORDER_ID', 0))
          if order_id:
              client.cancel_order(order_id, issue='CI job complete')
              print(f'Cancelled order {order_id}')
          "
```

### GitLab CI: बैच प्रोसेसिंग

```yaml
# .gitlab-ci.yml
gpu-batch-job:
  stage: process
  image: python:3.11
  variables:
    CLORE_API_KEY: $CLORE_API_KEY
  before_script:
    - pip install clore-ai
  script:
    - |
      python3 << 'EOF'
      from clore_ai import CloreAI
      import time

      client = CloreAI()

      servers = client.marketplace(gpu="RTX 4090", max_price_usd=3.0)
      if not servers:
          print("कोई GPUs उपलब्ध नहीं")
          exit(1)

      servers.sort(key=lambda s: s.price_usd or float("inf"))
      order = client.create_order(
          server_id=servers[0].id,
          image="cloreai/ubuntu22.04-cuda12",
          type="spot",
          currency="bitcoin",
          spot_price=0.00005,
          ports={"22": "tcp"}
      )
      print(f"तैनात किया गया: order {order.id}")

      # ... कार्य करें ...

      client.cancel_order(order.id)
      print("संपन्न और क्लीनअप किया गया")
      EOF
  after_script:
    - |
      python3 -c "
      from clore_ai import CloreAI
      client = CloreAI()
      for o in client.my_orders():
          client.cancel_order(o.id, issue='CI cleanup')
      "
```

***

## मॉनिटरिंग

### नियमित रूप से ऑर्डर जांचें

```bash
#!/bin/bash
# monitor.sh — हर 60 सेकंड में ऑर्डर जांचें

while true; do
    echo "=== $(date) ==="
    clore orders
    clore wallets
    echo ""
    sleep 60
done
```

### Python मॉनिटरिंग स्क्रिप्ट

```python
#!/usr/bin/env python3
"""monitor-orders.py — सक्रिय ऑर्डर की निगरानी करें और समस्याओं पर अलर्ट करें."""

import time
from clore_ai import CloreAI

POLL_INTERVAL = 60  # सेकंड
LOW_BALANCE_THRESHOLD = 0.001  # BTC

def monitor():
    client = CloreAI()

    while True:
        try:
            # ऑर्डर जांचें
            orders = client.my_orders()
            print(f"[{time.strftime('%H:%M:%S')}] सक्रिय ऑर्डर: {len(orders)}")
            for o in orders:
                print(f"  Order {o.id}: type={o.type}, IP={o.pub_cluster or 'pending'}")

            # बैलेंस जांचें
            wallets = client.wallets()
            for w in wallets:
                if w.name.lower() == "bitcoin" and w.balance < LOW_BALANCE_THRESHOLD:
                    print(f"  ⚠️  कम BTC बैलेंस: {w.balance:.8f}")

        except Exception as e:
            print(f"  ❌ त्रुटि: {e}")

        time.sleep(POLL_INTERVAL)

if __name__ == "__main__":
    monitor()
```

***

## बैच ऑपरेशन्स

### कई सर्वरों पर तैनात करें

```bash
#!/bin/bash
# batch-deploy.sh — कई सर्वरों पर तैनात करें

SERVER_IDS=(142 305 891 450)
IMAGE="cloreai/ubuntu22.04-cuda12"
PASSWORD="BatchRun$(date +%s)"

for SID in "${SERVER_IDS[@]}"; do
    echo "🚀 सर्वर $SID पर तैनात किया जा रहा है..."
    clore deploy "$SID" \
      --image "$IMAGE" \
      --type on-demand \
      --currency bitcoin \
      --ssh-password "$PASSWORD" \
      --port 22:tcp \
      || echo "⚠️  $SID पर तैनात करने में विफल"
    sleep 6  # रेट लिमिट का सम्मान करें
done

echo ""
echo "📦 सभी ऑर्डर:"
clore orders
echo "🔑 पासवर्ड: $PASSWORD"
```

### Python (Async) के साथ बैच तैनाती

```python
#!/usr/bin/env python3
"""batch-deploy.py — कई सर्वरों पर समवर्ती रूप से तैनात करें."""

import asyncio
from clore_ai import AsyncCloreAI
from clore_ai.exceptions import CloreAPIError

async def batch_deploy(server_ids, image="cloreai/ubuntu22.04-cuda12"):
    async with AsyncCloreAI() as client:
        tasks = [
            client.create_order(
                server_id=sid,
                image=image,
                type="on-demand",
                currency="bitcoin",
                ssh_password="BatchPass123",
                ports={"22": "tcp"}
            )
            for sid in server_ids
        ]

        results = await asyncio.gather(*tasks, return_exceptions=True)

        for sid, result in zip(server_ids, results):
            if isinstance(result, CloreAPIError):
                print(f"❌ सर्वर {sid}: {result}")
            elif isinstance(result, Exception):
                print(f"❌ सर्वर {sid}: {result}")
            else:
                print(f"✅ सर्वर {sid}: ऑर्डर {result.id}")

if __name__ == "__main__":
    import sys
    server_ids = [int(x) for x in sys.argv[1:]]
    if not server_ids:
        print("उपयोग: python batch-deploy.py 142 305 891")
        exit(1)
    asyncio.run(batch_deploy(server_ids))
```

उपयोग:

```bash
python batch-deploy.py 142 305 891
```

### स्पॉट मार्केट स्कैनर

```bash
#!/bin/bash
# spot-scanner.sh — सर्वरों की सूची के लिए स्पॉट कीमतें स्कैन करें

SERVERS=(6 12 42 100)

echo "📊 स्पॉट मार्केट स्कैन — $(date)"
echo "---"

for SID in "${SERVERS[@]}"; do
    echo "सर्वर $SID:"
    clore spot "$SID"
    echo ""
done
```

***

## क्रॉन जॉब्स

### दैनिक GPU कीमत जांच

```bash
# crontab में जोड़ें: crontab -e
# हर दिन सुबह 9 बजे चलाएं
0 9 * * * CLORE_API_KEY=your_key /usr/local/bin/clore search --gpu "RTX 4090" --sort price --limit 5 >> /var/log/clore-prices.log 2>&1
```

### घंटेवार बैलेंस जांच

```bash
# हर घंटे बैलेंस जांचें
0 * * * * CLORE_API_KEY=your_key /usr/local/bin/clore wallets >> /var/log/clore-balance.log 2>&1
```

***

## टिप्स

1. **हमेशा सेट करें `CLORE_API_KEY`** स्क्रिप्ट्स और CI में एक पर्यावरण चर के रूप में
2. **जोड़ें `sleep 6`** bash लूप्स में तैनाती कमांड्स के बीच रेट लिमिट का सम्मान करने के लिए
3. **उपयोग करें `--type spot`** बैच/CI जॉब्स के लिए — सस्ता और कट-छाट (interruptible) ठीक है
4. **ऑर्डर रद्द करें `after_script`** / `if: always()` भुली हुई बिलिंग से बचने के लिए
5. **SSH पासवर्ड सीक्रेट्स में स्टोर करें** (GitHub Secrets, GitLab CI Variables, आदि)
6. **उपयोग करें `clore orders --completed`** पिछले उपयोग का ऑडिट करने के लिए

***

## अगले कदम

* [Python SDK गाइड](https://docs.clore.ai/guides/guides_v2-hi/advanced/python-sdk) — async पैटर्न के साथ पूरा SDK संदर्भ
* [बैच प्रोसेसिंग](https://docs.clore.ai/guides/guides_v2-hi/advanced/batch-processing) — बड़े AI वर्कलोड्स प्रॉसेस करें
* [API एकीकरण](https://docs.clore.ai/guides/guides_v2-hi/advanced/api-integration) — अपने ऐप्स से AI सेवाओं को कनेक्ट करें