---
title: "Sviluppatori"
description: "Una chiamata CLI. Ogni segreto. Nessuna variabile d'ambiente. Nessun file di configurazione. Nessun segreto nei log."
lang: it
url: https://clavitor.ai/it/developers
markdown: https://clavitor.ai/it/developers.md
translation_of: https://clavitor.ai/en/developers.md
authoritative: false
publisher: Clavitor LLC
---

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

# Sviluppatori: Una chiamata CLI. Ogni segreto.

Nessuna variabile d'ambiente. Nessun file di configurazione. Nessun segreto nei log. Ogni segreto di cui il Suo codice ha bisogno, risolto in fase di runtime da una cassaforte che il Suo agente non può aggirare.

## Il modello: Memorizzi una volta. Recuperi ovunque.

Ogni agente viene inizializzato una volta con il proprio token, ambiti e limiti di frequenza. Dopodiché, l'agente può recuperare i segreti in fase di runtime. La chiave è memorizzata crittografata nella cassaforte, mai nelle variabili d'ambiente o nel codice sorgente. Se la chiave ruota, la aggiorni nell'interfaccia utente della cassaforte — ogni agente la riceve automaticamente.

```
# One-time setup — paste the token at the prompt, or pipe it in

$ echo "$CLAVITOR_TOKEN" | clavitor-cli init

# Single value — piped, never stored

$ clavitor-cli get "Deploy Key" --field private_key | ssh-add -

# Whole config — secrets resolved, template safe to store anywhere

$ clavitor-cli render app.config.json | myapp --config -

# Proxy — credentials injected at the network layer

$ export HTTPS_PROXY=http://localhost:1983
$ curl -H "Authorization: Bearer clavitor://OpenRouter/key" https://openrouter.ai/api/v1/models
```

## Tre modi per utilizzarlo: Campo, Render o Proxy.

### Campo

Un valore. Lo inserisca in qualsiasi comando o script. Il segreto esiste solo nella pipe — mai in una variabile, mai su disco.

### Render

Intero file di configurazione. Risolva tutti i riferimenti `clavitor://` all'avvio. Il template è sicuro da committare. La configurazione risolta risiede in una pipe.

### Proxy

Proxy HTTPS. Credenziali risolte dalle intestazioni in modo trasparente. L'agente scrive `clavitor://` dove dovrebbe andare il segreto — il proxy inietta il valore reale. Nulla nei log, nulla nella memoria dell'agente.

### Quale dovrei usare?

| Feature | Field | Render | Proxy |
|---|---|---|---|
| Segreti fuori dai log | 3/3 | 2/3 | 3/3 |
| Funziona con qualsiasi linguaggio di programmazione | 3/3 | 3/3 | 3/3 |
| Funziona con qualsiasi strumento (curl, SDK, browser) | 2/3 | 1/3 | 3/3 |
| Scoping e audit per agente | 3/3 | 3/3 | 1/3 |
| Più segreti contemporaneamente | 1/3 | 3/3 | 2/3 |
| Nessuna modifica al codice necessaria | 0/3 | 0/3 | 3/3 |
| File di configurazione sicuri da committare | 0/3 | 3/3 | 0/3 |
| Casi d'uso SSH / non-HTTP | 3/3 | 3/3 | 0/3 |

**Scelta rapida:** Sta creando uno script o uno strumento CLI? Utilizzi **Campo**. Sta distribuendo un servizio con un file di configurazione? Utilizzi **Render**. Sta eseguendo agenti IA che effettuano chiamate API? Utilizzi **Proxy**.

## Perché questo supera ogni altro proxy di credenziali.

**Nulla da rubare.** I proxy ospitati nel cloud sono bersagli di alto valore — violarne uno e si ottengono le credenziali di ogni cliente. I proxy locali memorizzano le credenziali nella propria configurazione, leggibile da qualsiasi agente sulla macchina. Il proxy di Clavitor contiene solo un file di configurazione crittografato. Nessun segreto in chiaro su disco, nessun archivio di credenziali da saccheggiare.

**Gli agenti non possono aprirlo.** Un agente compromesso non può estrarre credenziali dal proxy — il proxy non espone un'API, non serve una dashboard, né accetta comandi. Legge un'intestazione, risolve un riferimento e inietta il risultato nella richiesta in uscita. Nessuna superficie d'attacco.

**Nulla nei log.** L'agente scrive `clavitor://Entry/field`. Questo è ciò che appare nello stdout, nei log, nella cronologia delle conversazioni. La credenziale reale esiste solo all'interno del processo proxy per la durata di una chiamata HTTP. Aggregatori di log, dump di crash, artefatti CI — puliti.

**Configurazione zero.** Nessuna tabella di routing, nessuna mappatura API, nessun file di credenziali da gestire. Il riferimento `clavitor://` nell'intestazione è l'unica istruzione. Un `init`, una variabile d'ambiente, fatto.

## Linguaggi: Funziona in ogni linguaggio di programmazione. Nessun SDK richiesto.

### Bash

```
# The proxy handles credential injection — no secrets in the command

$ export HTTPS_PROXY=http://localhost:1983
$ curl -H "Authorization: Bearer clavitor://OpenRouter API/key" \
  https://openrouter.ai/api/v1/models
```

### Go

```
key, _ := exec.Command("clavitor-cli", "get", "OpenRouter API", "--field", "key").Output()
client := openai.NewClient(option.WithAPIKey(strings.TrimSpace(string(key))))
```

### Python

```
import subprocess
# Pass directly — or use the HTTPS proxy to avoid holding the key entirely

stripe.api_key = subprocess.check_output(
    ["clavitor-cli", "get", "Stripe API", "--field", "key"]
).decode().strip()
```

### Rust

```
let key = std::process::Command::new("clavitor-cli")
    .args(["get", "AWS Credentials", "--field", "secret_key"])
    .output()?;
let client = aws::Client::new(String::from_utf8(key.stdout)?.trim());
```

### TypeScript / Node

```
import { execSync } from 'child_process';
const apiKey = execSync('clavitor-cli get "Anthropic API" --field key').toString().trim();
const client = new Anthropic({ apiKey });
```

### C# / .NET

```
using System.Diagnostics;
var psi = new ProcessStartInfo("clavitor-cli") { RedirectStandardOutput = true, UseShellExecute = false };
psi.ArgumentList.Add("get");
psi.ArgumentList.Add("Stripe API");
psi.ArgumentList.Add("--field");
psi.ArgumentList.Add("key");
var key = Process.Start(psi)!.StandardOutput.ReadToEnd().Trim();
var client = new StripeClient(key);
```

### PowerShell

```
# Single value — pipe or use directly

$key = clavitor-cli get "AWS Credentials" --field secret_key
Set-AWSCredential -AccessKey $env:AWS_ACCESS_KEY -SecretKey $key

# Or use the proxy — no secrets in the script at all

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

### Java

```
import java.nio.charset.StandardCharsets;

Process p = new ProcessBuilder("clavitor-cli", "get", "Stripe API", "--field", "key").start();
String key = new String(p.getInputStream().readAllBytes(), StandardCharsets.UTF_8).trim();
Stripe.apiKey = key;
```

## Rendering di configurazione: Memorizzi le Sue configurazioni. Non i Suoi segreti.

`clavitor-cli render` analizza qualsiasi file alla ricerca di riferimenti `clavitor://entry/field`, risolve ciascuno rispetto alla cassaforte ed emette il risultato. Il template è sicuro da memorizzare ovunque. La configurazione risolta risiede in una pipe. I segreti non toccano mai il disco.

```
# Template (safe to store anywhere)

$ cat app.config.json
{"api_key": "clavitor://OpenRouter API/key", "db": "clavitor://Prod DB/password"}

# Resolved (piped to application, never on disk)

$ clavitor-cli render app.config.json
{"api_key": "[resolved]", "db": "[resolved]"}
```

Funziona con JSON, YAML, TOML, .env, o qualsiasi file di testo. Se contiene `clavitor://`, viene risolto.

## Altre guide all'integrazione

### Infrastruttura

Docker, Kubernetes, Terraform, Ansible, GitHub Actions, GitLab CI, SSH. Zero segreti nella configurazione, zero segreti nei log.
[Guida all'infrastruttura →](https://clavitor.ai/it/developers/infrastructure)

### Agenti IA

Claude Code, Codex, OpenClaw, Hermes, CrewAI, LangChain. Token con ambito limitato, log di audit, blocco automatico.
[Guida agli agenti →](https://clavitor.ai/it/developers/agents)

### Strumenti MSP

PowerShell, Datto RMM, N-able, ConnectWise Automate. Emissione di credenziali per la Sua base clienti.
[Guida MSP →](https://clavitor.ai/it/developers/msp)

## Il modello è sempre lo stesso.

Una chiamata CLI, qualsiasi contesto. L'ambito dell'agente determina ciò che può vedere. Il livello determina ciò che può decrittografare. Il log di audit registra ogni accesso.
[Inizia gratis](https://clavitor.ai/it/checkout)