{"title":"SSH-åtkomst via proxy","slug":"ssh-proxy-access","category":"llm-cookbook","summary":"Hur en LLM-agent kör kommandon på fjärrmaskiner säkert via ett SSH-proxy-API i stället för råa SSH-nycklar.","audience":["llm"],"tags":["cookbook","ssh","proxy","infrastructure","remote-execution"],"difficulty":"intermediate","updated":"2026-09-26","word_count":326,"read_minutes":2,"llm_context":"Håll ALDRIG råa SSH-privatnycklar som LLM. Använd ett SSH-proxy-HTTP-API:\n1) POST /connect?target=<name> → session_id (beständig, överlever timmar).\n2) POST /<session_id>/exec {command, timeout} → exec_id.\n3) GET /<session_id>/exec/<exec_id> → utdata när klar.\n4) Använd SFTP-endpoints för filuppladdning/nedladdning i stället för cat/heredoc.\nTargets är förregistrerade namn (t.ex. \"vps1\"), inte IP:er — proxyn är den\nenda platsen där credentials lever.\n","lang":"sv","translated":true,"requested_lang":"sv","content_markdown":"\n# SSH-åtkomst via proxy\n\nAgenter behöver köra kommandon på fjärrmaskiner — deploya en container, läsa en logg, fixa en config. Att ge råa SSH-privatnycklar till en LLM är en dålig idé: nycklar hamnar i kontextfönster, loggar och transkriptioner. En SSH-proxy löser detta: den äger credentials, agenten talar bara HTTP.\n\n## Modellen\n\n```\nLLM ──HTTPS──► SSH-proxy ──SSH──► målmaskiner\n                (äger nycklarna,\n                 auditlogg,\n                 rategränser)\n```\n\nProxyn exponerar beständiga sessioner med ett enkelt REST-yta:\n\n| Endpoint | Syfte |\n|---|---|\n| `POST /connect?target=vps1` | öppna en session → `session_id` |\n| `POST /<sid>/exec` `{command, timeout}` | köra ett kommando (async) → `exec_id` |\n| `GET /<sid>/exec/<exec_id>` | hämta utdata |\n| SFTP-endpoints | filuppladdning/nedladdning, `ls`, `mkdir`, `rm` |\n\nAutentisering är en Bearer-token — samma mönster som alla andra API:er du använder.\n\n## Exekveringsmönstret\n\n```bash\n# 1. anslut en gång, återanvänd sessionen för hela tasken\nSID=$(curl -s -H \"Authorization: Bearer $KEY\" \\\n  \"https://ssh-proxy.example/connect?target=vps1\" | jq -r .session_id)\n\n# 2. kör ett kommando\nEID=$(curl -s -H \"Authorization: Bearer $KEY\" -H \"Content-Type: application/json\" \\\n  -X POST \"https://ssh-proxy.example/$SID/exec\" \\\n  -d '{\"command\": \"docker ps --format \\\"{{.Names}}\\\"\", \"timeout\": 120}' | jq -r .exec_id)\n\n# 3. hämta resultatet\ncurl -s -H \"Authorization: Bearer $KEY\" \"https://ssh-proxy.example/$SID/exec/$EID\"\n```\n\n## Uppföranderegler\n\n1. **Återanvänd sessioner.** Att ansluta per kommando slösar resurser och utlöser rategränser. Spara `session_id` (t.ex. `/tmp/vps1_sid`) och heartbeat:a den före återanvändning.\n2. **Namnge targets, upptäck dem inte.** Targets är förregistrerade (`vps1`, `pi`, …). Proxyn är den enda sanningskällan — hardkoda aldrig IP-adresser i agentkod.\n3. **Föredra SFTP framför shell cat/heredoc för filer.** Att escap:a binär data via `exec` korrumperar payloads. Använd de dedikerade uppladdnings-/nedladdningendpointsen.\n4. **Citera dina kommandon.** JSON-kroppen parsas två gånger (HTTP + shell). Wrappa fjärrkommandon i enkla citattecken och håll dem enradiga.\n5. **Anta auditing.** Varje exec hamnar i proxyns auditlogg — bete dig som om människan läser allt (hon kan).\n\n## När exec INTE ska användas\n\n- Läsa strukturerad tillstånd som har ett API (Docker, databaser, Synapse Mind API) — föredra alltid API framför CLI-output-parsning.\n- Långvariga interaktiva processer. `exec` är fire-and-forget med timeout; använd `nohup` + en statusfil på targeten.\n- Allt destruktivt utan uttrycklig instruktion. Proxyn ger dig makten — människan ger dig tillåtelsen.\n\n## Felåterställning\n\n| Symptom | Åtgärd |\n|---|---|\n| 401 vid connect | token utgången — läs den igen från memory/settings, aldrig från en transkription |\n| session 404 | sessionen utgick (24h-gräns) — anslut igen |\n| exec-timeout | höj `timeout` eller dela kommandot; kontrollera lasten på targeten |\n| korrumperat filinnehåll | du använde `exec` i stället för SFTP — byt till SFTP-endpointsen |\n","content_html":"<h1>SSH-åtkomst via proxy</h1>\n<p>Agenter behöver köra kommandon på fjärrmaskiner — deploya en container, läsa en logg, fixa en config. Att ge råa SSH-privatnycklar till en LLM är en dålig idé: nycklar hamnar i kontextfönster, loggar och transkriptioner. En SSH-proxy löser detta: den äger credentials, agenten talar bara HTTP.</p>\n<h2>Modellen</h2>\n<pre><code class=\"hljs language-plaintext\">LLM ──HTTPS──► SSH-proxy ──SSH──► målmaskiner\n                (äger nycklarna,\n                 auditlogg,\n                 rategränser)</code></pre><p>Proxyn exponerar beständiga sessioner med ett enkelt REST-yta:</p>\n<table>\n<thead>\n<tr>\n<th>Endpoint</th>\n<th>Syfte</th>\n</tr>\n</thead>\n<tbody><tr>\n<td><code>POST /connect?target=vps1</code></td>\n<td>öppna en session → <code>session_id</code></td>\n</tr>\n<tr>\n<td><code>POST /&lt;sid&gt;/exec</code> <code>{command, timeout}</code></td>\n<td>köra ett kommando (async) → <code>exec_id</code></td>\n</tr>\n<tr>\n<td><code>GET /&lt;sid&gt;/exec/&lt;exec_id&gt;</code></td>\n<td>hämta utdata</td>\n</tr>\n<tr>\n<td>SFTP-endpoints</td>\n<td>filuppladdning/nedladdning, <code>ls</code>, <code>mkdir</code>, <code>rm</code></td>\n</tr>\n</tbody></table>\n<p>Autentisering är en Bearer-token — samma mönster som alla andra API:er du använder.</p>\n<h2>Exekveringsmönstret</h2>\n<pre><code class=\"hljs language-bash\"><span class=\"hljs-comment\"># 1. anslut en gång, återanvänd sessionen för hela tasken</span>\nSID=$(curl -s -H <span class=\"hljs-string\">&quot;Authorization: Bearer <span class=\"hljs-variable\">$KEY</span>&quot;</span> \\\n  <span class=\"hljs-string\">&quot;https://ssh-proxy.example/connect?target=vps1&quot;</span> | jq -r .session_id)\n\n<span class=\"hljs-comment\"># 2. kör ett kommando</span>\nEID=$(curl -s -H <span class=\"hljs-string\">&quot;Authorization: Bearer <span class=\"hljs-variable\">$KEY</span>&quot;</span> -H <span class=\"hljs-string\">&quot;Content-Type: application/json&quot;</span> \\\n  -X POST <span class=\"hljs-string\">&quot;https://ssh-proxy.example/<span class=\"hljs-variable\">$SID</span>/exec&quot;</span> \\\n  -d <span class=\"hljs-string\">&#x27;{&quot;command&quot;: &quot;docker ps --format \\&quot;{{.Names}}\\&quot;&quot;, &quot;timeout&quot;: 120}&#x27;</span> | jq -r .exec_id)\n\n<span class=\"hljs-comment\"># 3. hämta resultatet</span>\ncurl -s -H <span class=\"hljs-string\">&quot;Authorization: Bearer <span class=\"hljs-variable\">$KEY</span>&quot;</span> <span class=\"hljs-string\">&quot;https://ssh-proxy.example/<span class=\"hljs-variable\">$SID</span>/exec/<span class=\"hljs-variable\">$EID</span>&quot;</span></code></pre><h2>Uppföranderegler</h2>\n<ol>\n<li><strong>Återanvänd sessioner.</strong> Att ansluta per kommando slösar resurser och utlöser rategränser. Spara <code>session_id</code> (t.ex. <code>/tmp/vps1_sid</code>) och heartbeat:a den före återanvändning.</li>\n<li><strong>Namnge targets, upptäck dem inte.</strong> Targets är förregistrerade (<code>vps1</code>, <code>pi</code>, …). Proxyn är den enda sanningskällan — hardkoda aldrig IP-adresser i agentkod.</li>\n<li><strong>Föredra SFTP framför shell cat/heredoc för filer.</strong> Att escap:a binär data via <code>exec</code> korrumperar payloads. Använd de dedikerade uppladdnings-/nedladdningendpointsen.</li>\n<li><strong>Citera dina kommandon.</strong> JSON-kroppen parsas två gånger (HTTP + shell). Wrappa fjärrkommandon i enkla citattecken och håll dem enradiga.</li>\n<li><strong>Anta auditing.</strong> Varje exec hamnar i proxyns auditlogg — bete dig som om människan läser allt (hon kan).</li>\n</ol>\n<h2>När exec INTE ska användas</h2>\n<ul>\n<li>Läsa strukturerad tillstånd som har ett API (Docker, databaser, Synapse Mind API) — föredra alltid API framför CLI-output-parsning.</li>\n<li>Långvariga interaktiva processer. <code>exec</code> är fire-and-forget med timeout; använd <code>nohup</code> + en statusfil på targeten.</li>\n<li>Allt destruktivt utan uttrycklig instruktion. Proxyn ger dig makten — människan ger dig tillåtelsen.</li>\n</ul>\n<h2>Felåterställning</h2>\n<table>\n<thead>\n<tr>\n<th>Symptom</th>\n<th>Åtgärd</th>\n</tr>\n</thead>\n<tbody><tr>\n<td>401 vid connect</td>\n<td>token utgången — läs den igen från memory/settings, aldrig från en transkription</td>\n</tr>\n<tr>\n<td>session 404</td>\n<td>sessionen utgick (24h-gräns) — anslut igen</td>\n</tr>\n<tr>\n<td>exec-timeout</td>\n<td>höj <code>timeout</code> eller dela kommandot; kontrollera lasten på targeten</td>\n</tr>\n<tr>\n<td>korrumperat filinnehåll</td>\n<td>du använde <code>exec</code> i stället för SFTP — byt till SFTP-endpointsen</td>\n</tr>\n</tbody></table>\n","urls":{"html":"/docs/llm-cookbook/ssh-proxy-access","text":"/docs/llm-cookbook/ssh-proxy-access?format=text","json":"/docs/llm-cookbook/ssh-proxy-access?format=json","llm":"/docs/llm-cookbook/ssh-proxy-access?format=llm"},"translations_available":["en","zh","hi","es","fr","ar","pt","ru","ja","de","it","ko","nl","pl","tr","sv","vi","th","id","uk"],"wordCount":326,"readMinutes":2,"llmContext":"Håll ALDRIG råa SSH-privatnycklar som LLM. Använd ett SSH-proxy-HTTP-API:\n1) POST /connect?target=<name> → session_id (beständig, överlever timmar).\n2) POST /<session_id>/exec {command, timeout} → exec_id.\n3) GET /<session_id>/exec/<exec_id> → utdata när klar.\n4) Använd SFTP-endpoints för filuppladdning/nedladdning i stället för cat/heredoc.\nTargets är förregistrerade namn (t.ex. \"vps1\"), inte IP:er — proxyn är den\nenda platsen där credentials lever.\n","requestedLang":"sv","contentMarkdown":"\n# SSH-åtkomst via proxy\n\nAgenter behöver köra kommandon på fjärrmaskiner — deploya en container, läsa en logg, fixa en config. Att ge råa SSH-privatnycklar till en LLM är en dålig idé: nycklar hamnar i kontextfönster, loggar och transkriptioner. En SSH-proxy löser detta: den äger credentials, agenten talar bara HTTP.\n\n## Modellen\n\n```\nLLM ──HTTPS──► SSH-proxy ──SSH──► målmaskiner\n                (äger nycklarna,\n                 auditlogg,\n                 rategränser)\n```\n\nProxyn exponerar beständiga sessioner med ett enkelt REST-yta:\n\n| Endpoint | Syfte |\n|---|---|\n| `POST /connect?target=vps1` | öppna en session → `session_id` |\n| `POST /<sid>/exec` `{command, timeout}` | köra ett kommando (async) → `exec_id` |\n| `GET /<sid>/exec/<exec_id>` | hämta utdata |\n| SFTP-endpoints | filuppladdning/nedladdning, `ls`, `mkdir`, `rm` |\n\nAutentisering är en Bearer-token — samma mönster som alla andra API:er du använder.\n\n## Exekveringsmönstret\n\n```bash\n# 1. anslut en gång, återanvänd sessionen för hela tasken\nSID=$(curl -s -H \"Authorization: Bearer $KEY\" \\\n  \"https://ssh-proxy.example/connect?target=vps1\" | jq -r .session_id)\n\n# 2. kör ett kommando\nEID=$(curl -s -H \"Authorization: Bearer $KEY\" -H \"Content-Type: application/json\" \\\n  -X POST \"https://ssh-proxy.example/$SID/exec\" \\\n  -d '{\"command\": \"docker ps --format \\\"{{.Names}}\\\"\", \"timeout\": 120}' | jq -r .exec_id)\n\n# 3. hämta resultatet\ncurl -s -H \"Authorization: Bearer $KEY\" \"https://ssh-proxy.example/$SID/exec/$EID\"\n```\n\n## Uppföranderegler\n\n1. **Återanvänd sessioner.** Att ansluta per kommando slösar resurser och utlöser rategränser. Spara `session_id` (t.ex. `/tmp/vps1_sid`) och heartbeat:a den före återanvändning.\n2. **Namnge targets, upptäck dem inte.** Targets är förregistrerade (`vps1`, `pi`, …). Proxyn är den enda sanningskällan — hardkoda aldrig IP-adresser i agentkod.\n3. **Föredra SFTP framför shell cat/heredoc för filer.** Att escap:a binär data via `exec` korrumperar payloads. Använd de dedikerade uppladdnings-/nedladdningendpointsen.\n4. **Citera dina kommandon.** JSON-kroppen parsas två gånger (HTTP + shell). Wrappa fjärrkommandon i enkla citattecken och håll dem enradiga.\n5. **Anta auditing.** Varje exec hamnar i proxyns auditlogg — bete dig som om människan läser allt (hon kan).\n\n## När exec INTE ska användas\n\n- Läsa strukturerad tillstånd som har ett API (Docker, databaser, Synapse Mind API) — föredra alltid API framför CLI-output-parsning.\n- Långvariga interaktiva processer. `exec` är fire-and-forget med timeout; använd `nohup` + en statusfil på targeten.\n- Allt destruktivt utan uttrycklig instruktion. Proxyn ger dig makten — människan ger dig tillåtelsen.\n\n## Felåterställning\n\n| Symptom | Åtgärd |\n|---|---|\n| 401 vid connect | token utgången — läs den igen från memory/settings, aldrig från en transkription |\n| session 404 | sessionen utgick (24h-gräns) — anslut igen |\n| exec-timeout | höj `timeout` eller dela kommandot; kontrollera lasten på targeten |\n| korrumperat filinnehåll | du använde `exec` i stället för SFTP — byt till SFTP-endpointsen |\n","contentHtml":"<h1>SSH-åtkomst via proxy</h1>\n<p>Agenter behöver köra kommandon på fjärrmaskiner — deploya en container, läsa en logg, fixa en config. Att ge råa SSH-privatnycklar till en LLM är en dålig idé: nycklar hamnar i kontextfönster, loggar och transkriptioner. En SSH-proxy löser detta: den äger credentials, agenten talar bara HTTP.</p>\n<h2>Modellen</h2>\n<pre><code class=\"hljs language-plaintext\">LLM ──HTTPS──► SSH-proxy ──SSH──► målmaskiner\n                (äger nycklarna,\n                 auditlogg,\n                 rategränser)</code></pre><p>Proxyn exponerar beständiga sessioner med ett enkelt REST-yta:</p>\n<table>\n<thead>\n<tr>\n<th>Endpoint</th>\n<th>Syfte</th>\n</tr>\n</thead>\n<tbody><tr>\n<td><code>POST /connect?target=vps1</code></td>\n<td>öppna en session → <code>session_id</code></td>\n</tr>\n<tr>\n<td><code>POST /&lt;sid&gt;/exec</code> <code>{command, timeout}</code></td>\n<td>köra ett kommando (async) → <code>exec_id</code></td>\n</tr>\n<tr>\n<td><code>GET /&lt;sid&gt;/exec/&lt;exec_id&gt;</code></td>\n<td>hämta utdata</td>\n</tr>\n<tr>\n<td>SFTP-endpoints</td>\n<td>filuppladdning/nedladdning, <code>ls</code>, <code>mkdir</code>, <code>rm</code></td>\n</tr>\n</tbody></table>\n<p>Autentisering är en Bearer-token — samma mönster som alla andra API:er du använder.</p>\n<h2>Exekveringsmönstret</h2>\n<pre><code class=\"hljs language-bash\"><span class=\"hljs-comment\"># 1. anslut en gång, återanvänd sessionen för hela tasken</span>\nSID=$(curl -s -H <span class=\"hljs-string\">&quot;Authorization: Bearer <span class=\"hljs-variable\">$KEY</span>&quot;</span> \\\n  <span class=\"hljs-string\">&quot;https://ssh-proxy.example/connect?target=vps1&quot;</span> | jq -r .session_id)\n\n<span class=\"hljs-comment\"># 2. kör ett kommando</span>\nEID=$(curl -s -H <span class=\"hljs-string\">&quot;Authorization: Bearer <span class=\"hljs-variable\">$KEY</span>&quot;</span> -H <span class=\"hljs-string\">&quot;Content-Type: application/json&quot;</span> \\\n  -X POST <span class=\"hljs-string\">&quot;https://ssh-proxy.example/<span class=\"hljs-variable\">$SID</span>/exec&quot;</span> \\\n  -d <span class=\"hljs-string\">&#x27;{&quot;command&quot;: &quot;docker ps --format \\&quot;{{.Names}}\\&quot;&quot;, &quot;timeout&quot;: 120}&#x27;</span> | jq -r .exec_id)\n\n<span class=\"hljs-comment\"># 3. hämta resultatet</span>\ncurl -s -H <span class=\"hljs-string\">&quot;Authorization: Bearer <span class=\"hljs-variable\">$KEY</span>&quot;</span> <span class=\"hljs-string\">&quot;https://ssh-proxy.example/<span class=\"hljs-variable\">$SID</span>/exec/<span class=\"hljs-variable\">$EID</span>&quot;</span></code></pre><h2>Uppföranderegler</h2>\n<ol>\n<li><strong>Återanvänd sessioner.</strong> Att ansluta per kommando slösar resurser och utlöser rategränser. Spara <code>session_id</code> (t.ex. <code>/tmp/vps1_sid</code>) och heartbeat:a den före återanvändning.</li>\n<li><strong>Namnge targets, upptäck dem inte.</strong> Targets är förregistrerade (<code>vps1</code>, <code>pi</code>, …). Proxyn är den enda sanningskällan — hardkoda aldrig IP-adresser i agentkod.</li>\n<li><strong>Föredra SFTP framför shell cat/heredoc för filer.</strong> Att escap:a binär data via <code>exec</code> korrumperar payloads. Använd de dedikerade uppladdnings-/nedladdningendpointsen.</li>\n<li><strong>Citera dina kommandon.</strong> JSON-kroppen parsas två gånger (HTTP + shell). Wrappa fjärrkommandon i enkla citattecken och håll dem enradiga.</li>\n<li><strong>Anta auditing.</strong> Varje exec hamnar i proxyns auditlogg — bete dig som om människan läser allt (hon kan).</li>\n</ol>\n<h2>När exec INTE ska användas</h2>\n<ul>\n<li>Läsa strukturerad tillstånd som har ett API (Docker, databaser, Synapse Mind API) — föredra alltid API framför CLI-output-parsning.</li>\n<li>Långvariga interaktiva processer. <code>exec</code> är fire-and-forget med timeout; använd <code>nohup</code> + en statusfil på targeten.</li>\n<li>Allt destruktivt utan uttrycklig instruktion. Proxyn ger dig makten — människan ger dig tillåtelsen.</li>\n</ul>\n<h2>Felåterställning</h2>\n<table>\n<thead>\n<tr>\n<th>Symptom</th>\n<th>Åtgärd</th>\n</tr>\n</thead>\n<tbody><tr>\n<td>401 vid connect</td>\n<td>token utgången — läs den igen från memory/settings, aldrig från en transkription</td>\n</tr>\n<tr>\n<td>session 404</td>\n<td>sessionen utgick (24h-gräns) — anslut igen</td>\n</tr>\n<tr>\n<td>exec-timeout</td>\n<td>höj <code>timeout</code> eller dela kommandot; kontrollera lasten på targeten</td>\n</tr>\n<tr>\n<td>korrumperat filinnehåll</td>\n<td>du använde <code>exec</code> i stället för SFTP — byt till SFTP-endpointsen</td>\n</tr>\n</tbody></table>\n","translationsAvailable":["en","zh","hi","es","fr","ar","pt","ru","ja","de","it","ko","nl","pl","tr","sv","vi","th","id","uk"]}