--- title: "MSP-verktyg" description: "PowerShell, Datto RMM, N-able, ConnectWise Automate. Utfärdande av inloggningsuppgifter för din kundbas." lang: sv url: https://clavitor.ai/sv/developers/msp markdown: https://clavitor.ai/sv/developers/msp.md translation_of: https://clavitor.ai/en/developers/msp.md authoritative: false publisher: Clavitor LLC --- > This is the Swedish 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-verktyg: Din RMM gör redan API-anrop. Clavitor gör dem säkra. Dina tekniker använder Datto, N-able och ConnectWise varje dag. Varje skript, varje automatisering, varje schemalagd uppgift behöver inloggningsuppgifter. Idag finns de i skriptvariabler, anpassade fält eller ett delat valv som alla kan läsa. Clavitor-proxyn och CLI ändrar det utan att ändra dina arbetsflöden. ## Proxy-mönstret för RMM Ställ in `HTTPS_PROXY` på slutpunkten och dina befintliga skript fungerar oförändrade. Proxyn fångar upp utgående HTTPS-förfrågningar, löser `clavitor://`-referenser i rubriker och injicerar de verkliga inloggningsuppgifterna. Ditt skript ser aldrig hemligheten. Din RMM-konsol loggar den aldrig. ``` # 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 är MSP:ns dagliga språk. Både CLI och proxyn fungerar inbyggt. ### CLI — enskilda värden ``` # 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 ``` ### Rendera — konfigurationsmallar ``` # Template with clavitor:// references (safe to store in your RMM) clavitor-cli render monitoring-config.json | ` Set-Content -Path "C:\ProgramData\Monitor\config.json" ``` ### Proxy — transparent injicering ``` $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 ersätter platshållare för anpassade fält i skriptparametrar vid körning, med syntaxen `{[Atera..CustomField.]}`. Skicka Clavitor-token till ett engångsinstallationsskript som en parameter; senare skript anropar CLI på slutpunkten. ### Installera via IT Automation-profil I Ateras skriptbibliotek, skapa ett PowerShell-skript **Installera Clavitor** med en parameter. I IT Automation-profilen som kör det, anropa med kundnivåns fältplatshållare: ``` Install-Clavitor.ps1 -Token "{[Atera.Customer.CustomField.ClavitorToken]}" ``` Atera ersätter värdet innan agenten läser dess argumentlista. Skriptet: ``` param([Parameter(Mandatory)][string]$Token) $Token | clavitor-cli init Remove-Variable Token ``` ### Lös inloggningsuppgifter vid körning När slutpunkten är registrerad läser alla senare Atera-skript inloggningsuppgifter från valvet — Atera håller bara token-platsen: ``` $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 ersätter makron för Extra Data Field (EDF) i skriptstegsargument med syntaxen `{%^el:FieldName^%}` (datornivå EDF). CLI installeras via ett Automate-skript som laddar ner binären och anropar ett PowerShell-steg med token skickad som parameter — EDF-värdet ersätts innan skriptsteget körs. ### Automate-skript: installera I Automate-skriptredigeraren, skapa skriptet med två steg: ``` Step 1 File Download from LTShare clavitor-cli.exe → %windir%\Temp\ Step 2 Shell Execute (PowerShell) Install-Clavitor.ps1 -Token "{%^el:ClavitorToken^%}" ``` Makrot `{%^el:ClavitorToken^%}` ersätts med datornivåns EDF-värde innan PowerShell-steget körs. Håll tokens under 255 tecken för att hålla dig inom LabReplace:s ersättningsgräns. Själva skriptet: ``` # Install-Clavitor.ps1 param([Parameter(Mandatory)][string]$Token) $Token | clavitor-cli init Remove-Variable Token ``` ### Automate-skript: rotera en domäninloggningsuppgift Efterföljande skript läser från valvet och skriver en status tillbaka till EDF för dashboarding: ``` $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 exponerar webbplats- och globala variabler för PowerShell-komponenter som miljövariabler med prefixet `$env:`; användardefinierade fält (UDF) exponeras som `$env:UDF_1` till `$env:UDF_30`. En komponent installerar CLI; allt därefter läser från valvet. ### Komponent: installera och initialisera Definiera en webbplatsvariabel `ClavitorToken` i Datto-konsolen — den visas i komponenten som `$env:ClavitorToken`: ``` # Datto RMM component: bootstrap Clavitor CLI # Site variable "ClavitorToken" → $env:ClavitorToken at runtime $env:ClavitorToken | clavitor-cli init ``` ### Komponent: API-övervakning via proxyn Efterföljande komponenter skriver `clavitor://`-referenser i förfrågehuvuden — proxyn löser dem på värden. Inloggningsuppgifterna kommer aldrig in i skriptets minne eller Dattos loggar: ``` # 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-agentprocedurer ersätter `#variable#`-makron i PowerShell-argument vid körning, och kör sedan skriptet via familjen `executePowershell`-steg (`executePowerShell64BitSystem`, etc.). Ett anpassat fält på agentposten innehåller Clavitor-token; proceduren skickar den till init via stdin. ### Agentprocedur: installera Lägg till ett anpassat fält för agenten `ClavitorToken` (Audit → Edit Profile → Custom Fields), bygg sedan en procedur med två steg: ``` 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#" ``` Makrot `#vAgentConfiguration.ClavitorToken#` ersätts med värdet från det anpassade fältet innan VSA kör kommandot — token visas inte i VSAs procedurhistorik. ### Agentprocedur: rotera en privilegierad inloggningsuppgift När den är initialiserad läser alla senare procedurer från valvet: ``` # 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 Automationsenheten är en **AMP** (Automation Manager Policy) — en PowerShell-baserad policy byggd i Automation Manager. Anpassade egenskaper på organisations-, kund- eller webbplatsnivå kan skickas till ett `Run PowerShell Script`-objekt som indataparametrar. ### AMP: installera med anpassad egenskap som indata Lägg till en anpassad egenskap `ClavitorToken` på kundnivå (Administration → Custom Properties). I Automation Manager, skapa en AMP vars `Run PowerShell Script`-objekt binder indataparametern `Token` till den anpassade egenskapen. Skriptet: ``` param([Parameter(Mandatory)][string]$Token) $Token | clavitor-cli init Remove-Variable Token ``` Värdet från den anpassade egenskapen flödar in som `$Token`. Det visas aldrig i AMP:ns exporterade XML eller i N-centrals granskningslogg. ### Skriptarkiv: hämta en inloggningsuppgift vid körning För ad-hoc-skript som pushas via Skriptarkivet (Configuration → Repository → Scripts/Software), är slutpunkten redan initialiserad — skriptet anropar bara 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 (tidigare SolarWinds RMM) kör samma Automation Manager-motor som N-central, plus en Script Manager för `.ps1`, AMP, batch och andra skripttyper. Mönstret speglar N-central: AMP med en indataparameter för token, sedan löser allt annat sig vid körning. ### Script Manager: installera via Automatiserad Uppgift Ladda upp en `Install-Clavitor.ps1` till Settings → Script Manager med en parameter för token. Bifoga den som en Automatiserad Uppgift på slutpunkten; skicka token som ett skriptargument från enhetsnivåinställningen: ``` param([Parameter(Mandatory)][string]$Token) $Token | clavitor-cli init Remove-Variable Token ``` ### Automatiserad Uppgift: schemalagd säkerhetskopiering med inloggningsuppgifter från valvet När slutpunkten är initialiserad hämtar schemalagda uppgifter inloggningsuppgifter från valvet. All standardutdata upp till 255 tecken visas tillbaka till N-sight-instrumentpanelen: ``` $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-skript som körs på slutpunkten kan läsa och skriva anpassade fält genom inbyggda cmdlets: `Ninja-Property-Get ` returnerar värdet, `Ninja-Property-Set ` skriver tillbaka det. Lagra Clavitor-token i ett organisationsanpassat fält (typ **Secure** så det är skrivskyddat från konsolen); installationsskriptet läser det en gång. ### Installationsskript: läs token från anpassat fält I Administration → Library → Custom Fields, lägg till ett organisationsfält `clavitorToken` av typen Secure. Kör sedan ett installationsskript: ``` $token = Ninja-Property-Get clavitorToken $token | clavitor-cli init Remove-Variable token ``` ### Anpassad Åtgärd: API-anrop via proxyn När automatiseringar är installerade anropar de externa API:er via proxyn — inloggningsuppgifterna kopieras aldrig till en skriptvariabel: ``` $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 exponerar anpassade fält och taggar för tillgångar som **Platform**-skriptvariabler med syntaxen `{{asset_custom_field_}}` med dubbla klammerparenteser. Definiera en skriptvariabel av typen Platform och bind den till fältet — Syncro ersätter värdet i en PowerShell-parameter vid skriptkörning. ### Syncro-skript: installera Skapa ett anpassat fält för tillgångar `clavitor_token`. I skriptredigeraren, deklarera en variabel `Token` av typen **Platform** bunden till `{{asset_custom_field_clavitor_token}}`; skicka den till en PowerShell-parameter i skriptkroppen: ``` param([Parameter(Mandatory)][string]$Token) $Token | clavitor-cli init Remove-Variable Token ``` Hjälp-panelen längst ner i varje Syncro-skriptredigerare listar alla tillgängliga plattforms-variabler för tillgångs-, kund- och biljettkontexten. ### Syncro-skript: anslut VPN med inloggningsuppgifter från valvet Efter installation löser skript och Automatiserade Åtgärder inloggningsuppgifter från valvet och använder dem direkt: ``` $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 ``` ## Varför detta är viktigt för MSP:er Varje RMM-plattform lagrar inloggningsuppgifter någonstans — anpassade egenskaper, webbplatsvariabler, extra datafält, skriptparametrar. Varje tekniker med konsolåtkomst kan se dem. Varje intrång i din RMM-konsol exponerar alla kunders inloggningsuppgifter. Clavitor flyttar inloggningsuppgifterna ut ur RMM. RMM lagrar bara agent-token (en per kund). Token ger begränsad åtkomst till den kundens valv. Ett intrång i din RMM-konsol exponerar tokens, inte inloggningsuppgifter — och varje token är IP-vitlistad till den slutpunkt den distribuerades på. ### Omfattas per kund Varje kundvalv har sin egen agent-token. Teknikeråtkomst styrs av omfång, inte av "vem som kan logga in på RMM-konsolen." ### Granskas per skript Varje åtkomst till inloggningsuppgifter loggas — vilket skript, vilken slutpunkt, vilken inloggningsuppgift, när. Dina kunder kan se granskningsspåret. Du kan bevisa vem som fick åtkomst till vad. ### Återkallas med ett klick Kund lämnar? Återkalla deras agent-token. Varje slutpunkt slutar lösa inloggningsuppgifter omedelbart. Inga lösenord att rotera, inga anpassade egenskaper att rensa över 200 maskiner. ## Sluta lagra inloggningsuppgifter i din RMM. En CLI. Varje kund. Varje inloggningsuppgift omfattas, granskas och kan återkallas. [Kom igång gratis](https://clavitor.ai/sv/checkout) [Utvecklaröversikt →](https://clavitor.ai/sv/developers)