Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Ottieni un valore segreto di Secrets Manager usando Go con caching lato client
<a name="retrieving-secrets_cache-go"></a>

Quando si recupera un segreto, è possibile utilizzare il componente di caching basato su Go di Secrets Manager per memorizzarlo nella cache per un uso futuro. Il recupero di un segreto memorizzato nella cache è più veloce rispetto al recupero da Secrets Manager. Poiché la chiamata a Secrets Manager comporta un costo APIs, l'utilizzo di una cache può ridurre i costi. Per tutti i modi in cui puoi recuperare i segreti, vedi [Ottieni segreti](retrieving-secrets.md).

La policy della cache è Least Recently Used (LRU), quindi quando la cache deve eliminare un segreto, elimina il segreto usato meno di recente. Di default, la cache aggiorna i segreti ogni ora. È possibile configurare [la frequenza con cui il segreto viene aggiornato](retrieving-secrets_cache-go_CacheConfig.md) nella cache ed è possibile [collegarsi al recupero del segreto](retrieving-secrets_cache-go_CacheHook.md) per aggiungere altre funzionalità.

La cache non impone la rimozione di oggetti inutili (garbage collection) una volta liberati i riferimenti alla cache. L'implementazione della cache non include l'invalidazione della cache. L'implementazione della cache è incentrata sulla cache stessa e non è rafforzata o focalizzata sulla sicurezza. Se hai bisogno di un livello di sicurezza aggiuntivo, come la crittografia degli elementi nella cache, usa le interfacce e i metodi astratti forniti.

Per usare il componente, devi disporre dei seguenti elementi:
+ AWS SDK for Go. Per informazioni, consulta [AWS SDKs](asm_access.md#asm-sdks).

Per scaricare il codice sorgente, consulta [Secrets Manager Go caching client](https://github.com/aws/aws-secretsmanager-caching-go ) on GitHub.

Per configurare un ambiente di sviluppo Go, consulta [Introduzione a Golang](https://golang.org/doc/install) sul sito Web del linguaggio di programmazione Go.

**Autorizzazioni richieste:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`

Per ulteriori informazioni, consulta [Riferimento per le autorizzazioni](auth-and-access.md#reference_iam-permissions).

**Topics**
+ [type Cache](retrieving-secrets_cache-go_cache.md)
+ [tipo CacheConfig](retrieving-secrets_cache-go_CacheConfig.md)
+ [tipo CacheHook](retrieving-secrets_cache-go_CacheHook.md)

**Example Recupero di un segreto**  
L'esempio di codice riportato di seguito mostra una funzione Lambda che recupera un segreto.  

```
package main

import (
	 "github.com/aws/aws-lambda-go/lambda"
	 "github.com/aws/aws-secretsmanager-caching-go/secretcache"
)

var (
	 secretCache, _ = secretcache.New()
)

func HandleRequest(secretId string) string {
	 result, _ := secretCache.GetSecretString(secretId)
	 
	 // Use the secret, return success
}

 func main() {
	 lambda. Start( HandleRequest)
}
```

# type Cache
<a name="retrieving-secrets_cache-go_cache"></a>

Una cache in memoria per i segreti richiesti da Secrets Manager. Si usa [GetSecretString](#retrieving-secrets_cache-go_cache_operations_GetCachedSecret) o [GetSecretBinary](#retrieving-secrets_cache-go_cache_operations_GetSecretBinary) per recuperare un segreto dalla cache. 

Nell'esempio seguente viene illustrato come configurare le impostazioni della cache.

```
// Create a custom secretsmanager client
client := getCustomClient()

// Create a custom CacheConfig struct 
config := secretcache. CacheConfig{
    MaxCacheSize:  secretcache.DefaultMaxCacheSize + 10,
    VersionStage:  secretcache.DefaultVersionStage,
    CacheItemTTL:  secretcache.DefaultCacheItemTTL,
}
	
// Instantiate the cache 
cache, _ := secretcache.New(
    func( c *secretcache.Cache) {  c. CacheConfig = config },
    func( c *secretcache.Cache) {  c. Client = client },
)
```

Per ulteriori informazioni, inclusi esempi, consulta [Ottieni un valore segreto di Secrets Manager usando Go con caching lato client](retrieving-secrets_cache-go.md).

## Metodi
<a name="retrieving-secrets_cache-go_cache_operations"></a>

### Novità
<a name="retrieving-secrets_cache-go_cache_operations_New"></a>

`func New(optFns ...func(*Cache)) (*Cache, error)`

New costruisce una cache del segreto utilizzando opzioni funzionali, altrimenti usa i valori predefiniti. Inizializza un SecretsManager client da una nuova sessione. Inizializza CacheConfig ai valori predefiniti. Inizializza la cache LRU con una dimensione massima predefinita.

### GetSecretString
<a name="retrieving-secrets_cache-go_cache_operations_GetCachedSecret"></a>

`func (c *Cache) GetSecretString(secretId string) (string, error)`

GetSecretString ottiene il valore della stringa segreta dalla cache per un determinato ID segreto. Restituisce la stringa segreta e un errore se l'operazione non è riuscita.

### GetSecretStringWithStage
<a name="retrieving-secrets_cache-go_cache_operations_GetSecretStringWithStage"></a>

`func (c *Cache) GetSecretStringWithStage(secretId string, versionStage string) (string, error)`

GetSecretStringWithStage ottiene il valore della stringa segreta dalla cache per un determinato ID segreto e [fase della versione](whats-in-a-secret.md#term_version). Restituisce la stringa segreta e un errore se l'operazione non è riuscita.

### GetSecretBinary
<a name="retrieving-secrets_cache-go_cache_operations_GetSecretBinary"></a>

`func (c *Cache) GetSecretBinary(secretId string) ([]byte, error) {`

GetSecretBinary ottiene il valore binario segreto dalla cache per un determinato ID segreto. Restituisce il numero binario del segreto e un errore in caso di errore dell'operazione.

### GetSecretBinaryWithStage
<a name="retrieving-secrets_cache-go_cache_operations_GetSecretBinaryWithStage"></a>

`func (c *Cache) GetSecretBinaryWithStage(secretId string, versionStage string) ([]byte, error)`

GetSecretBinaryWithStage ottiene il valore binario segreto dalla cache per un determinato ID segreto e [fase della versione](whats-in-a-secret.md#term_version). Restituisce il numero binario del segreto e un errore in caso di errore dell'operazione. 

# tipo CacheConfig
<a name="retrieving-secrets_cache-go_CacheConfig"></a>

Opzioni di configurazione della cache per una [Cache](retrieving-secrets_cache-go_cache.md), ad esempio dimensione massima della cache, [fase della versione](whats-in-a-secret.md#term_version) di default e durata (TTL) per i segreti memorizzati nella cache.

```
type CacheConfig struct {

    // The maximum cache size. The default is 1024 secrets.
    MaxCacheSize int
            
    // The TTL of a cache item in nanoseconds. The default is 
    // 3.6e10^12 ns or 1 hour.
    CacheItemTTL int64
            
    // The version of secrets that you want to cache. The default 
    // is "AWSCURRENT".
    VersionStage string
            
    // Used to hook in-memory cache updates.
    Hook CacheHook
}
```

# tipo CacheHook
<a name="retrieving-secrets_cache-go_CacheHook"></a>

Un'interfaccia per collegarsi a una [Cache](retrieving-secrets_cache-go_cache.md) per eseguire operazioni sul segreto memorizzato al suo interno.

## Metodi
<a name="retrieving-secrets_cache-go_CacheHook_operations"></a>

### Put
<a name="retrieving-secrets_cache-go_CacheHook_operations_Put"></a>

`Put(data interface{}) interface{}`

Prepara l'oggetto per la memorizzazione nella cache.

### Get
<a name="retrieving-secrets_cache-go_CacheHook_operations_Get"></a>

`Get(data interface{}) interface{}`

Deriva l'oggetto dall'oggetto memorizzato nella cache.