---
title: "MSP टूल्स"
description: "PowerShell, Datto RMM, N-able, ConnectWise Automate. आपके क्लाइंट बेस के लिए क्रेडेंशियल जारी करना।"
lang: hi
url: https://clavitor.ai/hi/developers/msp
markdown: https://clavitor.ai/hi/developers/msp.md
translation_of: https://clavitor.ai/en/developers/msp.md
authoritative: false
publisher: Clavitor LLC
---

> This is the Hindi translation of [MSP Tools](https://clavitor.ai/en/developers/msp.md). The original English text is authoritative; where the two differ, the English version prevails.

# MSP टूल्स: आपका RMM पहले से ही API कॉल करता है। Clavitor उन्हें सुरक्षित बनाता है।

आपके तकनीशियन हर दिन Datto, N-able, और ConnectWise का उपयोग करते हैं। हर स्क्रिप्ट, हर ऑटोमेशन, हर शेड्यूल किए गए टास्क को क्रेडेंशियल की आवश्यकता होती है। आज वे स्क्रिप्ट वेरिएबल्स, कस्टम फ़ील्ड्स, या एक साझा वॉल्ट में हैं जिसे हर कोई पढ़ सकता है। Clavitor प्रॉक्सी और CLI आपके वर्कफ़्लो को बदले बिना इसे बदल देते हैं।

## RMM के लिए प्रॉक्सी पैटर्न

एंडपॉइंट पर `HTTPS_PROXY` सेट करें और आपकी मौजूदा स्क्रिप्ट्स बिना किसी बदलाव के काम करेंगी। प्रॉक्सी आउटबाउंड HTTPS अनुरोधों को इंटरसेप्ट करती है, हेडर्स में `clavitor://` संदर्भों को रिज़ॉल्व करती है, और वास्तविक क्रेडेंशियल इंजेक्ट करती है। आपकी स्क्रिप्ट कभी भी सीक्रेट नहीं देखती है। आपका RMM कंसोल कभी भी इसे लॉग नहीं करता है।

```
# On the managed endpoint — one-time setup

$env:HTTPS_PROXY = "http://localhost:1983"

# Your existing automation scripts work unchanged

# The proxy resolves clavitor:// references in request headers

Invoke-RestMethod -Uri "https://api.openai.com/v1/models" `
  -Headers @{ Authorization = "Bearer clavitor://OpenAI/key" }
```

## PowerShell

PowerShell MSP की दैनिक भाषा है। CLI और प्रॉक्सी दोनों मूल रूप से काम करते हैं।

### CLI — एकल मान

```
# Resolve, use, scrub — the credential lives for one statement

$cred = clavitor-cli get "Client-Acme/VPN" --field password
Add-VpnConnection -Name "Acme" -ServerAddress "vpn.acme.com" -AuthenticationMethod MSChapv2
$secure = ConvertTo-SecureString $cred -AsPlainText -Force
Set-VpnConnectionUsernamePassword -ConnectionName "Acme" -Password $secure
Remove-Variable cred, secure
```

### Render — कॉन्फ़िग टेम्पलेट्स

```
# Template with clavitor:// references (safe to store in your RMM)

clavitor-cli render monitoring-config.json | `
  Set-Content -Path "C:\ProgramData\Monitor\config.json"
```

### प्रॉक्सी — पारदर्शी इंजेक्शन

```
$env:HTTPS_PROXY = "http://localhost:1983"

# Every Invoke-RestMethod and Invoke-WebRequest now resolves clavitor://

Invoke-RestMethod -Uri "https://api.datto.com/v1/devices" `
  -Headers @{ Authorization = "Bearer clavitor://Datto API/key" }
```

## Atera

Atera रन टाइम पर `{[Atera.<level>.CustomField.<name>]}` सिंटैक्स का उपयोग करके स्क्रिप्ट पैरामीटर्स में कस्टम-फ़ील्ड प्लेसहोल्डर्स को प्रतिस्थापित करता है। Clavitor टोकन को एक पैरामीटर के रूप में वन-टाइम इंस्टॉल स्क्रिप्ट में पास करें; बाद की स्क्रिप्ट्स एंडपॉइंट पर CLI को शेल आउट करती हैं।

### IT ऑटोमेशन प्रोफ़ाइल के माध्यम से इंस्टॉल करें

Atera स्क्रिप्ट लाइब्रेरी में, एक पैरामीटर के साथ **Install Clavitor** PowerShell स्क्रिप्ट बनाएं। इसे चलाने वाली IT ऑटोमेशन प्रोफ़ाइल में, कस्टमर-लेवल फ़ील्ड प्लेसहोल्डर के साथ इनवोक करें:

```
Install-Clavitor.ps1 -Token "{[Atera.Customer.CustomField.ClavitorToken]}"
```

एजेंट के अपनी आर्ग लिस्ट पढ़ने से पहले Atera मान को प्रतिस्थापित करता है। स्क्रिप्ट:

```
param([Parameter(Mandatory)][string]$Token)
$Token | clavitor-cli init
Remove-Variable Token
```

### रनटाइम पर क्रेडेंशियल रिज़ॉल्व करें

एक बार एंडपॉइंट एनरोल हो जाने के बाद, हर बाद की Atera स्क्रिप्ट वॉल्ट से क्रेडेंशियल पढ़ती है — Atera केवल टोकन स्लॉट रखता है:

```
$pass = clavitor-cli get "Client-Acme/SQL Server" --field password
$secure = ConvertTo-SecureString $pass -AsPlainText -Force
Invoke-Sqlcmd -ServerInstance "sql.acme.local" `
  -Credential (New-Object PSCredential("sa", $secure)) -Query "SELECT 1"
Remove-Variable pass, secure
```

## ConnectWise Automate

Automate `{%^el:FieldName^%}` सिंटैक्स (कंप्यूटर-लेवल EDF) का उपयोग करके स्क्रिप्ट स्टेप आर्ग्युमेंट्स में एक्स्ट्रा डेटा फ़ील्ड (EDF) मैक्रोज़ को प्रतिस्थापित करता है। CLI एक Automate स्क्रिप्ट के माध्यम से इंस्टॉल होता है जो बाइनरी डाउनलोड करती है और पैरामीटर के रूप में पास किए गए टोकन के साथ PowerShell स्टेप को इनवोक करती है — स्क्रिप्ट स्टेप निष्पादित होने से पहले EDF मान बदल दिया जाता है।

### Automate स्क्रिप्ट: इंस्टॉल

Automate स्क्रिप्ट एडिटर में, दो स्टेप्स के साथ स्क्रिप्ट बनाएं:

```
Step 1  File Download from LTShare       clavitor-cli.exe → %windir%\Temp\
Step 2  Shell Execute (PowerShell)       Install-Clavitor.ps1 -Token "{%^el:ClavitorToken^%}"
```

PowerShell स्टेप चलने से पहले `{%^el:ClavitorToken^%}` मैक्रो को कंप्यूटर-लेवल EDF मान से बदल दिया जाता है। LabReplace की प्रतिस्थापन सीमा के भीतर रहने के लिए टोकन को 255 वर्णों से कम रखें। स्वयं स्क्रिप्ट:

```
# Install-Clavitor.ps1

param([Parameter(Mandatory)][string]$Token)
$Token | clavitor-cli init
Remove-Variable Token
```

### Automate स्क्रिप्ट: डोमेन क्रेडेंशियल की रोटेशन करें

बाद की स्क्रिप्ट्स वॉल्ट से पढ़ती हैं और डैशबोर्डिंग के लिए EDF में स्थिति वापस लिखती हैं:

```
$cred = clavitor-cli get "Client-Delta/Domain Admin" --field password
$secure = ConvertTo-SecureString $cred -AsPlainText -Force
Reset-ComputerMachinePassword `
  -Credential (New-Object PSCredential("administrator", $secure))
# Push timestamp back to EDF "LastRotation" via Automate's ExtraData Set Value step

Write-Output (Get-Date -Format o)
Remove-Variable cred, secure
```

## Datto RMM

Datto RMM साइट और ग्लोबल वेरिएबल्स को `$env:` प्रीफ़िक्स के साथ एनवायरनमेंट वेरिएबल्स के रूप में PowerShell कंपोनेंट्स के सामने प्रस्तुत करता है; यूज़र-डिफ़ाइंड फ़ील्ड्स (UDFs) `$env:UDF_1` से `$env:UDF_30` तक के रूप में प्रस्तुत किए जाते हैं। एक कंपोनेंट CLI इंस्टॉल करता है; उसके बाद की हर चीज़ वॉल्ट से पढ़ती है।

### कंपोनेंट: इंस्टॉल और इनिशियलाइज़

Datto कंसोल में एक साइट वेरिएबल `ClavitorToken` परिभाषित करें — यह कंपोनेंट के अंदर `$env:ClavitorToken` के रूप में दिखाई देता है:

```
# Datto RMM component: bootstrap Clavitor CLI

# Site variable "ClavitorToken" → $env:ClavitorToken at runtime

$env:ClavitorToken | clavitor-cli init
```

### कंपोनेंट: प्रॉक्सी के माध्यम से API मॉनिटर

बाद के कंपोनेंट्स अनुरोध हेडर्स में `clavitor://` संदर्भ लिखते हैं — प्रॉक्सी उन्हें होस्ट पर रिज़ॉल्व करती है। क्रेडेंशियल कभी भी स्क्रिप्ट की मेमोरी या Datto के लॉग में प्रवेश नहीं करता है:

```
# Scheduled monitor — runs every 15 minutes

$env:HTTPS_PROXY = "http://localhost:1983"
$response = Invoke-RestMethod -Uri "https://api.client.com/v1/status" `
  -Headers @{ Authorization = "Bearer clavitor://Client-Bravo/Monitoring API" }

# Push a status code back into UDF_5 for the Datto dashboard

New-ItemProperty -Path "HKLM:\SOFTWARE\CentraStage" `
  -Name "Custom5" -Value $response.status -Force | Out-Null
```

## Kaseya VSA

VSA एजेंट प्रोसीजर्स रन टाइम पर PowerShell आर्ग्युमेंट्स में `#variable#` मैक्रोज़ को प्रतिस्थापित करते हैं, फिर `executePowershell` स्टेप फैमिली (`executePowerShell64BitSystem`, आदि) के माध्यम से स्क्रिप्ट निष्पादित करते हैं। एजेंट रिकॉर्ड पर एक कस्टम फ़ील्ड Clavitor टोकन रखती है; प्रोसीजर इसे stdin के माध्यम से init को पास करता है।

### एजेंट प्रोसीजर: इंस्टॉल

एक एजेंट कस्टम फ़ील्ड `ClavitorToken` जोड़ें (Audit → Edit Profile → Custom Fields), फिर दो स्टेप्स के साथ एक प्रोसीजर बनाएं:

```
Step 1  Get File from VSA Server     clavitor-cli.exe → C:\Program Files\Clavitor\
Step 2  Execute PowerShell (64 Sys)  "C:\Program Files\Clavitor\clavitor-cli.exe init" \
                                     stdin = "#vAgentConfiguration.ClavitorToken#"
```

VSA के कमांड निष्पादित करने से पहले `#vAgentConfiguration.ClavitorToken#` मैक्रो को कस्टम फ़ील्ड मान से बदल दिया जाता है — टोकन VSA की प्रोसीजर हिस्ट्री में दिखाई नहीं देता है।

### एजेंट प्रोसीजर: विशेषाधिकार प्राप्त क्रेडेंशियल की रोटेशन करें

एक बार इनिशियलाइज़ हो जाने के बाद, कोई भी बाद की प्रोसीजर वॉल्ट से पढ़ती है:

```
# Executed via executePowerShell64BitSystem

$cred = clavitor-cli get "Client-Hotel/Local Admin" --field password
$secure = ConvertTo-SecureString $cred -AsPlainText -Force
Set-LocalUser -Name "Administrator" -Password $secure
Remove-Variable cred, secure
```

## N-able N-central

ऑटोमेशन की इकाई एक **AMP** (Automation Manager Policy) है — Automation Manager में निर्मित एक PowerShell-आधारित पॉलिसी। संगठन, कस्टमर, या साइट स्तर पर कस्टम प्रॉपर्टीज़ को `Run PowerShell Script` ऑब्जेक्ट को इनपुट पैरामीटर्स के रूप में पास किया जा सकता है।

### AMP: इनपुट के रूप में कस्टम प्रॉपर्टी के साथ इंस्टॉल

कस्टमर स्तर पर एक कस्टम प्रॉपर्टी `ClavitorToken` जोड़ें (Administration → Custom Properties)। Automation Manager में, एक AMP बनाएं जिसका `Run PowerShell Script` ऑब्जेक्ट इनपुट पैरामीटर `Token` को उस कस्टम प्रॉपर्टी से बाइंड करता है। स्क्रिप्ट:

```
param([Parameter(Mandatory)][string]$Token)
$Token | clavitor-cli init
Remove-Variable Token
```

कस्टम प्रॉपर्टी मान `$Token` के रूप में प्रवाहित होता है। यह कभी भी AMP के निर्यात किए गए XML या N-central के ऑडिट लॉग में दिखाई नहीं देता है।

### स्क्रिप्ट रिपॉजिटरी: रनटाइम पर एक क्रेडेंशियल फ़ेच करें

स्क्रिप्ट रिपॉजिटरी (Configuration → Repository → Scripts/Software) के माध्यम से पुश की गई एड-हॉक स्क्रिप्ट्स के लिए, एंडपॉइंट पहले से ही इनिशियलाइज़्ड है — स्क्रिप्ट बस CLI को कॉल करती है:

```
$dbPass = clavitor-cli get "Client-Bcme/SQL Server" --field password
$secure = ConvertTo-SecureString $dbPass -AsPlainText -Force
Invoke-Sqlcmd -ServerInstance "sql.bcme.com" `
  -Credential (New-Object PSCredential("sa", $secure)) -Query "SELECT 1"
Remove-Variable dbPass, secure
```

## N-able N-sight

N-sight (पूर्व में SolarWinds RMM) N-central के समान Automation Manager इंजन चलाता है, साथ ही `.ps1`, AMP, बैच, और अन्य स्क्रिप्ट प्रकारों के लिए एक स्क्रिप्ट मैनेजर भी। पैटर्न N-central को दर्शाता है: टोकन के लिए एक इनपुट पैरामीटर के साथ AMP, फिर बाकी सब कुछ रनटाइम पर रिज़ॉल्व होता है।

### स्क्रिप्ट मैनेजर: ऑटोमेटेड टास्क के माध्यम से इंस्टॉल

टोकन के लिए एक पैरामीटर के साथ Settings → Script Manager में `Install-Clavitor.ps1` अपलोड करें। इसे एंडपॉइंट पर एक ऑटोमेटेड टास्क के रूप में अटैच करें; डिवाइस-लेवल सेटिंग से टोकन को स्क्रिप्ट आर्ग्युमेंट के रूप में पास करें:

```
param([Parameter(Mandatory)][string]$Token)
$Token | clavitor-cli init
Remove-Variable Token
```

### ऑटोमेटेड टास्क: वॉल्ट क्रेडेंशियल के साथ शेड्यूल किया गया बैकअप

एक बार इनिशियलाइज़ हो जाने के बाद, शेड्यूल किए गए टास्क वॉल्ट से क्रेडेंशियल पुल करते हैं। 255 वर्णों तक का कोई भी मानक आउटपुट वापस N-sight डैशबोर्ड पर दिखाई देता है:

```
$pass = clavitor-cli get "Client-India/SQL Backup" --field password
$secure = ConvertTo-SecureString $pass -AsPlainText -Force
Backup-SqlDatabase -ServerInstance "sql.india.com" -Database "AppDB" `
  -Credential (New-Object PSCredential("backup-svc", $secure))
Write-Output "backup OK $(Get-Date -Format o)"
Remove-Variable pass, secure
```

## NinjaOne

एंडपॉइंट पर चल रही NinjaOne स्क्रिप्ट्स बिल्ट-इन कमांडलेट्स के माध्यम से कस्टम फ़ील्ड्स को पढ़ और लिख सकती हैं: `Ninja-Property-Get <name>` मान लौटाता है, `Ninja-Property-Set <name> <value>` इसे वापस लिखता है। Clavitor टोकन को एक संगठन कस्टम फ़ील्ड में स्टोर करें (टाइप **Secure** ताकि यह कंसोल से केवल राइट-ओनली हो); इंस्टॉल स्क्रिप्ट इसे एक बार पढ़ती है।

### इंस्टॉल स्क्रिप्ट: कस्टम फ़ील्ड से टोकन पढ़ें

Administration → Library → Custom Fields में, Secure प्रकार की एक संगठन फ़ील्ड `clavitorToken` जोड़ें। फिर एक इंस्टॉल स्क्रिप्ट चलाएं:

```
$token = Ninja-Property-Get clavitorToken
$token | clavitor-cli init
Remove-Variable token
```

### कस्टम एक्शन: प्रॉक्सी के माध्यम से API कॉल

एक बार इंस्टॉल हो जाने के बाद, ऑटोमेशन्स प्रॉक्सी के माध्यम से बाहरी API को कॉल करते हैं — क्रेडेंशियल कभी भी स्क्रिप्ट वेरिएबल में कॉपी नहीं किया जाता है:

```
$env:HTTPS_PROXY = "http://localhost:1983"
$response = Invoke-RestMethod -Uri "https://api.client-echo.com/v1/status" `
  -Headers @{ Authorization = "Bearer clavitor://Client-Echo/Monitoring API" }

# Push the result back to a device custom field for dashboarding

Ninja-Property-Set lastApiStatus $response.status
```

## Syncro

Syncro `{{asset_custom_field_<name>}}` डबल-कर्ली सिंटैक्स का उपयोग करके एसेट कस्टम फ़ील्ड्स और टैग्स को **Platform** स्क्रिप्ट वेरिएबल्स के रूप में प्रस्तुत करता है। Platform प्रकार का एक स्क्रिप्ट वेरिएबल परिभाषित करें और इसे फ़ील्ड से बाइंड करें — Syncro स्क्रिप्ट-रन टाइम पर मान को PowerShell पैरामीटर में प्रतिस्थापित करता है।

### Syncro स्क्रिप्ट: इंस्टॉल

एक एसेट कस्टम फ़ील्ड `clavitor_token` बनाएं। स्क्रिप्ट एडिटर में, `{{asset_custom_field_clavitor_token}}` से बाइंड **Platform** प्रकार का एक वेरिएबल `Token` डिक्लेयर करें; इसे स्क्रिप्ट बॉडी में एक PowerShell पैरामीटर को पास करें:

```
param([Parameter(Mandatory)][string]$Token)
$Token | clavitor-cli init
Remove-Variable Token
```

हर Syncro स्क्रिप्ट एडिटर के निचले भाग में स्थित क्विक हेल्प पैनल एसेट, कस्टमर और टिकट संदर्भ के लिए उपलब्ध हर प्लेटफ़ॉर्म वेरिएबल को सूचीबद्ध करता है।

### Syncro स्क्रिप्ट: वॉल्ट क्रेडेंशियल के साथ VPN कनेक्ट करें

इंस्टॉल के बाद, स्क्रिप्ट्स और ऑटोमेटेड रिमेडिएशन्स वॉल्ट से क्रेडेंशियल रिज़ॉल्व करते हैं और उनका सीधे उपयोग करते हैं:

```
$pass = clavitor-cli get "Client-Golf/VPN" --field password
$secure = ConvertTo-SecureString $pass -AsPlainText -Force
Add-VpnConnection -Name "Golf" -ServerAddress "vpn.golf.com" `
  -AuthenticationMethod MSChapv2 -Force
Set-VpnConnectionUsernamePassword -ConnectionName "Golf" -Password $secure
# Write status back to asset for Syncro dashboard

Rmm-Alert -Category "vpn-status" -Body "Golf connected $(Get-Date -Format o)"
Remove-Variable pass, secure
```

## यह MSP के लिए क्यों मायने रखता है

हर RMM प्लेटफ़ॉर्म क्रेडेंशियल को कहीं न कहीं स्टोर करता है — कस्टम प्रॉपर्टीज़, साइट वेरिएबल्स, एक्स्ट्रा डेटा फ़ील्ड्स, स्क्रिप्ट पैरामीटर्स। कंसोल एक्सेस वाला हर तकनीशियन उन्हें देख सकता है। आपके RMM कंसोल का हर ब्रीच हर क्लाइंट के क्रेडेंशियल को उजागर करता है।

Clavitor क्रेडेंशियल को RMM से बाहर ले जाता है। RMM केवल एजेंट टोकन (प्रति क्लाइंट एक) स्टोर करता है। टोकन उस क्लाइंट के वॉल्ट तक परिधिबद्ध एक्सेस प्रदान करता है। आपके RMM कंसोल का ब्रीच क्रेडेंशियल को नहीं, बल्कि टोकन को उजागर करता है — और प्रत्येक टोकन उस एंडपॉइंट के लिए IP-व्हाइटलिस्टेड होता है जहां इसे डिप्लॉय किया गया था।

### प्रति क्लाइंट परिधिबद्ध

प्रत्येक क्लाइंट वॉल्ट का अपना एजेंट टोकन होता है। तकनीशियन एक्सेस परिधिबद्धता द्वारा नियंत्रित होता है, न कि "RMM कंसोल में कौन लॉग इन कर सकता है" द्वारा।

### प्रति स्क्रिप्ट ऑडिटेड

हर क्रेडेंशियल एक्सेस लॉग किया जाता है — कौन सी स्क्रिप्ट, कौन सा एंडपॉइंट, कौन सा क्रेडेंशियल, कब। आपके क्लाइंट ऑडिट ट्रेल देख सकते हैं। आप साबित कर सकते हैं कि किसने क्या एक्सेस किया।

### एक क्लिक में रिवोक

क्लाइंट छोड़ देता है? उनके एजेंट टोकन को रिवोक करें। हर एंडपॉइंट तुरंत क्रेडेंशियल रिज़ॉल्व करना बंद कर देता है। रोटेशन के लिए कोई पासवर्ड नहीं, 200 मशीनों पर क्लियर करने के लिए कोई कस्टम प्रॉपर्टी नहीं।

## अपने RMM में क्रेडेंशियल स्टोर करना बंद करें।

एक CLI. हर क्लाइंट. हर क्रेडेंशियल परिधिबद्ध, ऑडिटेड और रिवोक करने योग्य।
[मुफ़्त शुरू करें](https://clavitor.ai/hi/checkout)
[डेवलपर अवलोकन →](https://clavitor.ai/hi/developers)
