# General Translation Platform: Chiavi API
URL: https://generaltranslation.com/it/docs/platform/dashboard/reference/api-keys.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Crea e gestisci le chiavi API del progetto e dell'organizzazione per app, sviluppo locale e automazione. Riferimento per le chiavi API.

Le chiavi API autenticano le tue app, la CLI e l&#39;automazione con General Translation. Usa l&#39;ambito della chiave più ristretto adatto al workflow.

## Ambiti delle chiavi [#key-scopes]

General Translation supporta due ambiti per le chiavi API:

* **Chiavi di organizzazione** per l&#39;automazione a livello di organizzazione. Usale per l&#39;automazione a livello di organizzazione o per workflow che devono operare tra più progetti dell&#39;organizzazione.
* **Chiavi di progetto** per un singolo progetto. Usale negli ambienti server, nello sviluppo locale e negli strumenti a livello di progetto. Non includerle mai nei bundle distribuiti per browser o app mobili.

Nella Dashboard, entrambi gli ambiti supportano le autorizzazioni **All** o **Custom**. **All** concede tutte le autorizzazioni che puoi delegare all&#39;interno di quell&#39;ambito. **Custom** ti consente di selezionare un insieme più ristretto; seleziona almeno un&#39;autorizzazione. Puoi concedere solo le autorizzazioni di cui disponi.

## Crea chiavi di organizzazione [#create-organization-keys]

Crea chiavi di organizzazione da **organizzazione &gt; Developer &gt; Chiavi API**. Le chiavi di organizzazione usano il prefisso `gtx-org-` e possono essere configurate con un set di autorizzazioni personalizzato.

In questi controlli della Dashboard, le autorizzazioni sono configurate per risorsa. `Write` include `Read`.

| Risorsa                             | Read                                                       | Scrittura o abilitato                                                                                         |
| ----------------------------------- | ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| **Creazione di progetti**           | Non applicabile                                            | Creare nuovi progetti nell&#39;organizzazione                                                                 |
| **Chiavi API del progetto**         | Visualizzare le chiavi API dei progetti                    | Visualizzare, creare ed eliminare chiavi API del progetto                                                     |
| **File**                            | Leggere i file e le traduzioni del progetto                | Caricare contenuti sorgente e scrivere file tradotti                                                          |
| **Contesto**                        | Leggere il contesto del progetto e dell&#39;organizzazione | Gestire gruppi di contesto, Glossario e prompt personalizzati                                                 |
| **Risorse dell&#39;organizzazione** | Non applicabile                                            | Caricare e sostituire risorse, come i font, condivise da tutti i progetti dell&#39;organizzazione             |
| **Runtime translation**             | Non applicabile                                            | Tradurre contenuti su richiesta                                                                               |
| **Coda di traduzione**              | Non applicabile                                            | Mettere in coda i job di traduzione dei file per l&#39;elaborazione in background                             |
| **Impostazioni del progetto**       | Non applicabile                                            | Aggiornare le impostazioni del progetto, come l&#39;impostazione regionale predefinita e la distribuzione CDN |

Abilita **Creazione di progetti** per l&#39;automazione che chiama l&#39;endpoint [Create a project](/docs/platform/openapi/reference/projects/create-project). La sua autorizzazione `org:projects:create` consente anche di creare progetti con la distribuzione CDN abilitata; **Impostazioni del progetto** (`project:write`) serve solo per aggiornare le impostazioni in un secondo momento. Concedi a ogni chiave solo le autorizzazioni necessarie.

Imposta **Contesto** su **Read** o **Scrittura** per l&#39;automazione che chiama la [Context Management API](/docs/platform/openapi/reference/context-groups/list-context-groups) (`org:context:read` / `org:context:write`). Una chiave di organizzazione con questa autorizzazione può operare su tutti i gruppi di contesto dell&#39;organizzazione. Una [chiave di progetto](#create-project-keys) può accedere solo ai gruppi assegnati al proprio progetto e non può creare, aggiornare, eliminare, assegnare o rimuovere l&#39;assegnazione di un gruppo.

Imposta **Risorse dell&#39;organizzazione** su **Scrittura** per l&#39;automazione che carica i font per la traduzione Lottie, come la sincronizzazione [`fonts`](/docs/cli/reference/config#fonts) della CLI (`org:assets:write`). Le chiavi di progetto non possono caricare font.

Imposta **Chiavi API del progetto** su **Scrittura** per l&#39;automazione che chiama [Create a project API Key](/docs/platform/openapi/reference/api-keys/create-project-api-key) o [Delete a project API key](/docs/platform/openapi/reference/api-keys/delete-project-api-key). **Read** è sufficiente per [elencare](/docs/platform/openapi/reference/api-keys/list-project-api-keys) o [recuperare](/docs/platform/openapi/reference/api-keys/get-project-api-key) le chiavi di un progetto, operazione che non restituisce mai i relativi segreti. Per un progetto di un&#39;organizzazione, usa una chiave di quell&#39;organizzazione dotata delle autorizzazioni richieste. Le chiavi di progetto non possono elencare, creare o eliminare chiavi.

Quando crei chiavi tramite l&#39;[API HTTP](/docs/platform/openapi/reference/api-keys/create-project-api-key), seleziona le autorizzazioni in modo esplicito oppure ometti la selezione per concedere tutte le autorizzazioni del progetto che puoi delegare. A differenza dei controlli della Dashboard, le autorizzazioni Scrittura concesse esplicitamente tramite HTTP non includono Read.

## Creare chiavi di progetto [#create-project-keys]

Crea le chiavi di progetto da **progetto &gt; Chiavi API**. Le nuove chiavi iniziano con `gtx-api-` e funzionano in development, staging e produzione. Le relative autorizzazioni determinano quali operazioni possono eseguire.

1. Crea una chiave e inserisci un **Nome** descrittivo.
2. In **autorizzazioni**, scegli **All** o **Custom**.
3. Con **Custom**, seleziona l&#39;accesso necessario per ciascuna risorsa.
4. Seleziona **Create**, quindi copia subito la chiave completa. Conservala in variabili d&#39;ambiente o in un gestore di segreti.

Le chiavi di progetto supportano queste risorse:

| Resource                      | Read                                               | Scrittura o enabled                                                                       |
| ----------------------------- | -------------------------------------------------- | ------------------------------------------------------------------------------------- |
| **file**                      | Leggere file e traduzioni del progetto             | Caricare contenuto sorgente e scrivere i file tradotti                                |
| **contesto**                  | Leggere i gruppi di contesto assegnati al progetto | Generare contesto, modificare e riordinare i gruppi di contesto assegnati al progetto |
| **Runtime translation**       | Non applicabile                                    | Tradurre contenuti su richiesta                                                       |
| **coda di traduzione**        | Non applicabile                                    | Accodare job di traduzione di file                                                    |
| **impostazioni del progetto** | Non applicabile                                    | Aggiornare le impostazioni del progetto                                               |

Con **contesto**, una chiave di progetto può chiamare la [Context Management API](/docs/platform/openapi/reference/context-groups/list-context-groups) per i gruppi di contesto assegnati al proprio progetto. **Read** (`project:context:read`) consente di elencare tali gruppi e di leggerne ed esportarne il Glossario e i Prompt Personalizzati. **Scrittura** (`project:context:write`) consente inoltre di modificare e importare tali contenuti, riordinare i gruppi e generare contesto. Una chiave di progetto non può creare, aggiornare, eliminare, assegnare o rimuovere l&#39;assegnazione di un gruppo di contesto: queste azioni richiedono una chiave di organizzazione. Un gruppo non assegnato al progetto della chiave restituisce lo stesso `403` di un gruppo inesistente.

Per la traduzione su richiesta in locale è sufficiente qualsiasi chiave di progetto con `project:translations:generate`, compresa una chiave con accesso completo. Per ridurre al minimo i rischi, consigliamo una chiave dedicata con autorizzazioni **Custom**: imposta **Runtime translation** su **Enabled** e lascia le altre risorse su **None**. Per una pipeline di traduzione di file, concedi **file &gt; Scrittura** (che include Read), **coda di traduzione &gt; Enabled** e **contesto &gt; Scrittura**. [`gt translate`](/docs/cli/reference/commands/translate) genera il contesto prima di accodare le traduzioni, quindi senza **contesto &gt; Scrittura** l&#39;operazione non va a buon fine. Se invece crei la chiave tramite l&#39;API HTTP o con [`gt api-key create`](/docs/cli/reference/commands/api-key-create), richiedi esplicitamente `project:files:read`, `project:files:write`, `project:translations:enqueue` e `project:context:write`, perché in quel caso Scrittura non include Read.

L&#39;impostazione dell&#39;SDK `devApiKey` e la variabile d&#39;ambiente `GT_DEV_API_KEY` continuano ad abilitare la traduzione di sviluppo e l&#39;hot reload. In quell&#39;impostazione indica una chiave di progetto con l&#39;autorizzazione di runtime translation. Il nome dell&#39;impostazione non implica un key type separato.

Nella maggior parte dei flussi di lavoro con SDK e CLI, usa la chiave insieme al tuo project ID:

```bash
GT_API_KEY=gtx-api-...
GT_PROJECT_ID=...
```

Per l&#39;accesso alla CLI tramite account, usa [`gt login`](/docs/cli/reference/commands/login). Per creare dalla CLI una chiave di progetto con autorizzazioni esplicite, usa [`gt api-key create`](/docs/cli/reference/commands/api-key-create).

## Gestisci le chiavi [#manage-keys]

Usa nomi descrittivi, così sarà più facile identificare le chiavi in seguito.

Apri l&#39;elenco delle chiavi del progetto o di organizzazione per esaminare le chiavi esistenti. L&#39;elenco delle chiavi mostra:

* **Nome** e **Chiave**, inclusa una versione abbreviata della chiave per identificarla
* **Autorizzazioni**, sia per le chiavi di progetto sia per quelle di organizzazione
* **Creata il**, la data in cui la chiave è stata generata
* **Ultimo utilizzo**, quando la chiave è stata usata l&#39;ultima volta

Se disponi del permesso per gestire le chiavi, usa **Modifica chiave** per rinominare una chiave o aggiornarne le autorizzazioni ed **Elimina** per revocarla. Il segreto completo viene mostrato solo al momento della creazione della chiave.

Revoca le chiavi che non vengono più usate e creane di nuove quando effettui la rotazione delle credenziali. In genere una chiave eliminata smette di funzionare per l&#39;autenticazione immediatamente e, in ogni caso, entro 10 minuti.

Per ruotare una chiave di progetto da un&#39;automazione, [crea](/docs/platform/openapi/reference/api-keys/create-project-api-key) la chiave sostitutiva, aggiorna il tuo flusso di lavoro in modo che la utilizzi, quindi [elimina](/docs/platform/openapi/reference/api-keys/delete-project-api-key) la vecchia chiave tramite il suo ID. Entrambe le chiamate richiedono una chiave di organizzazione con **Chiavi API del progetto** impostate su **Scrittura**.

## Chiavi di sviluppo esistenti [#existing-keys]

Le chiavi `gtx-dev-` esistenti continuano ad autenticarsi come chiavi di progetto. Le chiavi con la vecchia autorizzazione predefinita limitata al runtime ricevono ora le autorizzazioni di progetto predefinite, che includono file, contesto, coda di traduzione e impostazioni del progetto. Gli altri set di autorizzazioni personalizzate vengono mantenuti.

Controlla le chiavi esistenti in **Project &gt; API Keys**. Per lo sviluppo locale, consigliamo di limitarle a **Runtime translation** oppure di sostituirle con nuove chiavi limitate al runtime. Le chiavi con accesso completo continuano a funzionare, ma il prefisso `gtx-dev-` non implica più autorizzazioni limitate. Non includere mai queste chiavi nei bundle client distribuiti.

## Pratiche di sicurezza [#security-practices]

* Non eseguire mai il commit delle chiavi nel sistema di controllo versione.
* Non includere mai alcuna chiave API nei bundle distribuiti del browser o delle app mobile, indipendentemente dalle sue autorizzazioni. Conserva le credenziali distribuite in variabili d&#39;ambiente server-side o in un gestore di segreti.
* Le chiavi API possono essere usate nel codice client servito esclusivamente dal tuo server di sviluppo locale. Le chiavi di progetto con accesso completo funzionano, ma consigliamo di limitare le chiavi di sviluppo locale a **Runtime translation** (`project:translations:generate`) per ridurre al minimo i rischi.
* Conserva le chiavi nelle variabili d&#39;ambiente o in un gestore di segreti.
* Usa chiavi separate per sviluppo, staging e produzione.
* Ruota periodicamente le chiavi.
* Revoca le chiavi non utilizzate.
* Preferisci l&#39;ambito più limitato che funzioni per l&#39;integrazione.

## Sitemap

See the full [sitemap](https://generaltranslation.com/sitemap.md) for all pages.
