> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/advanced/cli-automation.md).

# CLI ऑटोमेशन

{% hint style="success" %}
**पूर्वापेक्षाएँ:** SDK स्थापित करें (`pip install clore-ai`) और अपनी API कुंजी कॉन्फ़िगर करें। देखें [Python क्विकस्टार्ट](/guides/guides_v2-hi/getting-started/python-quickstart.md) यदि आपने अभी तक नहीं किया है।
{% 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 गाइड](/guides/guides_v2-hi/advanced/python-sdk.md) — async पैटर्न के साथ पूरा SDK संदर्भ
* [बैच प्रोसेसिंग](/guides/guides_v2-hi/advanced/batch-processing.md) — बड़े AI वर्कलोड्स प्रॉसेस करें
* [API एकीकरण](/guides/guides_v2-hi/advanced/api-integration.md) — अपने ऐप्स से AI सेवाओं को कनेक्ट करें


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/advanced/cli-automation.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.