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à. # Usa Gestione dei segreti AWS i segreti in Amazon Elastic Kubernetes Service Per mostrare i segreti di Gestione dei segreti AWS (ASCP) come file montati in Amazon EKS Pods, puoi utilizzare AWS Secrets and Configuration Provider per il driver CSI Kubernetes Secrets Store. L'ASCP funziona con Amazon Elastic Kubernetes Service 1.17\$1 che esegue un gruppo di nodi Amazon EC2. AWS Fargate i gruppi di nodi non sono supportati. Con ASCP, è possibile archiviare e gestire i segreti in Secrets Manager e recuperarli tramite i carichi di lavoro in esecuzione su Amazon EKS. Se il tuo segreto contiene più coppie chiave-valore in formato JSON, puoi scegliere quali montare in Amazon EKS. L'ASCP utilizza la sintassi JMESPath per interrogare le coppie chiave-valore nel tuo segreto. L'ASCP funziona anche con i parametri dell'archivio parametri. L'ASCP offre due metodi di autenticazione con Amazon EKS. Il primo approccio utilizza i ruoli IAM per gli account di servizio (IRSA). Il secondo approccio utilizza Pod Identity. Ogni approccio ha i suoi vantaggi e casi d'uso. ## ASCP con ruoli IAM per gli account di servizio (IRSA) L'ASCP con IAM Roles for Service Accounts (IRSA) ti consente di montare segreti da file Gestione dei segreti AWS as nei tuoi Amazon EKS Pods. Questo approccio è adatto quando: + Devi montare i segreti come file nei tuoi Pods. + Stai usando la versione 1.17 o quella successiva di Amazon EKS con i gruppi di nodi di Amazon EC2. + Vuoi recuperare coppie chiave-valore specifiche da segreti in formato JSON. Per ulteriori informazioni, consulta [Usa AWS Secrets and Configuration Provider CSI con IAM Roles for Service Accounts (IRSA)](integrating_ascp_irsa.md). ## ASCP con Pod Identity Il metodo ASCP con Pod Identity migliora la sicurezza e semplifica la configurazione per l'accesso ai segreti in Amazon EKS. Questo approccio è utile quando: + È necessaria una gestione delle autorizzazioni più granulare a livello di pod. + Stai utilizzando la versione 1.24 o quella successiva di Amazon EKS. + Desideri prestazioni e scalabilità migliorate. Per ulteriori informazioni, consulta [Usa AWS Secrets e Configuration Provider CSI con Pod Identity per Amazon EKS](ascp-pod-identity-integration.md). ## Scelta dell'approccio giusto Considera i seguenti fattori al momento di decidere tra ASCP con IRSA e ASCP con Pod Identity: + Amazon EKSversion: Pod Identity richiede Amazon EKS 1.24\$1, mentre il driver CSI funziona con Amazon EKS 1.17\$1. + Requisiti di sicurezza: Pod Identity offre un controllo più granulare a livello di pod. + Prestazioni: Pod Identity generalmente offre prestazioni migliori in ambienti su larga scala. + Complessità: Pod Identity semplifica la configurazione eliminando la necessità di account di servizio separati. Scegli il metodo più adatto ai tuoi requisiti specifici e all'ambiente Amazon EKS. # Installa ASCP per Amazon EKS Questa sezione spiega come installare AWS Secrets and Configuration Provider per Amazon EKS. Con ASCP, puoi montare segreti da Secrets Manager e parametri da AWS Systems Manager file in Amazon EKS Pods. ## Prerequisiti + Cluster Amazon EKS + Versione 1.24 o successiva per Pod Identity + Versione 1.17 o successiva per IRSA + AWS CLI Installato e configurato + kubectl installato e configurato per il cluster Amazon EKS + Helm (versione 3.0 o successiva) ## Istalla e configura l'ASCP L'ASCP è disponibile GitHub nel repository [secrets-store-csi-provider-aws](https://github.com/aws/secrets-store-csi-driver-provider-aws). Il repository contiene anche file YAML di esempio per la creazione e il montaggio di un segreto. Durante l'installazione, puoi configurare l'ASCP per utilizzare un endpoint FIPS. Per un elenco di endpoint, consulta [Gestione dei segreti AWS endpoint](asm_access.md#endpoints). **Per installare ASCP come componente aggiuntivo EKS** 1. Installazione `eksctl` (istruzioni di [installazione](https://docs.aws.amazon.com/eks/latest/eksctl/installation.html)) 1. Eseguite il comando seguente per installare il componente aggiuntivo con la [configurazione predefinita](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/charts/secrets-store-csi-driver-provider-aws/values.yaml): ``` eksctl create addon --cluster --name aws-secrets-store-csi-driver-provider ``` Se desideri configurare il componente aggiuntivo, esegui invece il seguente comando di installazione: ``` aws eks create-addon --cluster-name --addon-name aws-secrets-store-csi-driver-provider --configuration-values 'file://path/to/config.yaml' ``` Il file di configurazione può essere un file YAML o JSON. Per visualizzare lo schema di configurazione del componente aggiuntivo: 1. Eseguite il comando seguente e prendete nota della versione più recente del componente aggiuntivo: ``` aws eks describe-addon-versions --addon-name aws-secrets-store-csi-driver-provider ``` 1. Esegui il comando seguente per visualizzare lo schema di configurazione del componente aggiuntivo, sostituendolo `` con la versione del passaggio precedente: ``` aws eks describe-addon-configuration --addon-name aws-secrets-store-csi-driver-provider --addon-version ``` **Installazione dell'ASCP con l'utilizzo di Helm** 1. Per assicurarti che il repository punti al grafico più recente, utilizza `helm repo update.` 1. Installare il grafico. Di seguito è riportato un esempio del `helm install` comando: ``` helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws ``` 1. Per utilizzare un endpoint FIPS, aggiungi il seguente flag: `--set useFipsEndpoint=true` 1. Per configurare la limitazione (della larghezza di banda della rete), aggiungi il seguente flag: `--set-json 'k8sThrottlingParams={"qps": "number of queries per second", "burst": "number of queries per second"}'` 1. Se il driver CSI Secrets Store è già installato sul cluster, aggiungi il seguente flag:`--set secrets-store-csi-driver.install=false`. Ciò eviterà l'installazione del driver CSI di Secrets Store come dipendenza. **Installazione utilizzando lo YAML nel repository** + Utilizza i seguenti comandi: ``` helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts helm install -n kube-system csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/deployment/aws-provider-installer.yaml ``` ## Verifica le installazioni Per verificare le installazioni del cluster EKS, del driver CSI di Secrets Store e del plug-in ASCP, procedi nel seguente modo: 1. Verifica il cluster EKS: ``` eksctl get cluster --name clusterName ``` Questo comando deve restituire informazioni sul cluster. 1. Verifica l'installazione del driver CSI di Secrets Store: ``` kubectl get pods -n kube-system -l app=secrets-store-csi-driver ``` Dovresti vedere dei pod in esecuzione con nomi come `csi-secrets-store-secrets-store-csi-driver-xxx`. 1. Verifica l'installazione del plugin ASCP: ------ #### [ YAML installation ] ``` $ kubectl get pods -n kube-system -l app=csi-secrets-store-provider-aws ``` Output di esempio: ``` NAME READY STATUS RESTARTS AGE csi-secrets-store-provider-aws-12345 1/1 Running 0 2m ``` ------ #### [ Helm installation ] ``` $ kubectl get pods -n kube-system -l app=secrets-store-csi-driver-provider-aws ``` Output di esempio: ``` NAME READY STATUS RESTARTS AGE secrets-provider-aws-secrets-store-csi-driver-provider-67890 1/1 Running 0 2m ``` ------ Dovresti vedere dei pod nello stato `Running`. Dopo aver eseguito questi comandi, se tutto è impostato correttamente, dovresti vedere tutti i componenti in esecuzione senza errori. In caso di problemi, potrebbe essere necessario risolverli controllando i log dei pod specifici che presentano problemi. ## Risoluzione dei problemi 1. Per controllare i log del provider ASCP, esegui: ``` kubectl logs -n kube-system -l app=csi-secrets-store-provider-aws ``` 1. Controlla lo stato di tutti i pod nel namespace: `kube-system` ``` kubectl -n kube-system get pods ``` ``` kubectl -n kube-system logs pod/PODID ``` Tutti i pod relativi al driver CSI e all'ASCP devono essere nello stato "In esecuzione". 1. Controlla la versione del driver CSI: ``` kubectl get csidriver secrets-store.csi.k8s.io -o yaml ``` Questo comando deve restituire informazioni sul driver CSI installato. ## Risorse aggiuntive Per ulteriori informazioni su come utilizzare ASCP con Amazon EKS, consulta le seguenti risorse: + [Utilizzo di Pod Identity con Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html) + [AWS Driver CSI Secrets Store attivo GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws) # Usa AWS Secrets e Configuration Provider CSI con Pod Identity per Amazon EKS L'integrazione di AWS Secrets and Configuration Provider con Pod Identity Agent per Amazon Elastic Kubernetes Service offre maggiore sicurezza, configurazione semplificata e prestazioni migliorate per le applicazioni in esecuzione su Amazon EKS. Pod Identity semplifica l'autenticazione IAM per Amazon EKS durante il recupero di segreti da Secrets Manager o parametri da AWS Systems Manager Parameter Store. Amazon EKS Pod Identity semplifica il processo di configurazione delle autorizzazioni IAM per le applicazioni Kubernetes consentendo quest'azione direttamente tramite le interfacce Amazon EKS, riducendo il numero di passaggi ed eliminando la necessità di passare da Amazon EKS ai servizi IAM. [Pod Identity consente l'uso di un singolo ruolo IAM su più cluster senza aggiornare le policy di attendibilità e supporta i tag delle sessioni di ruolo](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html#pod-id-abac-tags) per un controllo degli accessi più granulare. Questo approccio non solo semplifica la gestione delle policy consentendo il riutilizzo delle politiche di autorizzazione tra i ruoli, ma migliora anche la sicurezza abilitando l'accesso alle risorse in base ai AWS tag corrispondenti. ## Come funziona 1. Pod Identity assegna un ruolo IAM al pod. 1. ASCP utilizza questo ruolo per l'autenticazione con. Servizi AWS 1. Se autorizzato, ASCP recupera i segreti richiesti e li rende disponibili al Pod. Per ulteriori informazioni, consulta [Scopri come funziona Amazon EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html) nella *Guida per l'utente di Amazon EKS*. ## Prerequisiti **Importante** Pod Identity è supportato solo per Amazon EKS nel cloud. Non è supportato per [Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/) o per i cluster [Servizio Red Hat OpenShift su AWS](https://aws.amazon.com/rosa/)Kubernetes autogestiti sulle istanze Amazon EC2. + Cluster Amazon EKS (versione 1.24 o successiva) + Accesso AWS CLI e cluster Amazon EKS tramite `kubectl` + Accesso a due Account AWS (per l'accesso su più account) ## Installazione dell'agente Amazon EKS Pod Identity Per utilizzare Pod Identity con il tuo cluster, devi installare il componente aggiuntivo dell'agente Amazon EKS Pod Identity. **Installare l'agente Pod Identity** + Installa il componente aggiuntivo Pod Identity Agent sul tuo cluster: ``` eksctl create addon \ --name eks-pod-identity-agent \ --cluster clusterName \ --region region ``` ## Configura ASCP con Pod Identity 1. Crea una politica di autorizzazioni che conceda `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` autorizzi i segreti a cui il Pod deve accedere. Per un esempio di policy, consulta [Esempio: autorizzazione a leggere e descrivere singoli segreti](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe). 1. Crea un ruolo IAM che può essere assunto dal servizio principale Amazon EKS per Pod Identity: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "pods.eks.amazonaws.com" }, "Action": [ "sts:AssumeRole", "sts:TagSession" ] } ] } ``` ------ Allega la policy IAM al ruolo: ``` aws iam attach-role-policy \ --role-name MY_ROLE \ --policy-arn POLICY_ARN ``` 1. Crea un'associazione Pod Identity. Per un esempio, consulta [Crea un'associazione Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html#pod-id-association-create) nella *Guida per l'utente Amazon EKS* 1. Crea il `SecretProviderClass` file che specifica quali segreti montare nel Pod: ``` kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleSecretProviderClass-PodIdentity.yaml ``` La differenza fondamentale in `SecretProviderClass` tra IRSA e Pod Identity è il parametro `usePodIdentity` facoltativo. Si tratta di un campo facoltativo che determina l'approccio di autenticazione. Quando non è specificato, per impostazione predefinita utilizzare i ruoli IAM per gli account di servizio (IRSA). + Per utilizzare EKS Pod Identity, utilizza uno qualsiasi di questi valori: `"true", "True", "TRUE", "t", "T"`. + Per utilizzare in modo esplicito IRSA, imposta uno qualsiasi di questi valori: `"false", "False", "FALSE", "f", or "F"`. 1. Implementa il Pod che monta i segreti sotto: `/mnt/secrets-store` ``` kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleDeployment-PodIdentity.yaml ``` 1. Se utilizzi un cluster Amazon EKS privato, assicurati che il VPC in cui si trova il cluster abbia un AWS STS endpoint. Per informazioni sulla creazione di un endpoint, consulta [Endpoint VPC di interfaccia](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) nella * Guida per l'utente AWS Identity and Access Management *. ### Verifica il montaggio del segreto Per verificare che il segreto sia montato correttamente, esegui il seguente comando: ``` kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MySecret ``` **Per configurare Amazon EKS Pod Identity per l'accesso ai segreti in Secrets Manager** 1. Crea una politica di autorizzazioni che conceda `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` autorizzi i segreti a cui il Pod deve accedere. Per un esempio di policy, consulta [Esempio: autorizzazione a leggere e descrivere singoli segreti](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe). 1. Crea un segreto in Secrets Manager, se non ne hai già uno. ## Risoluzione dei problemi È possibile visualizzare la maggior parte degli errori descrivendo l'implementazione del pod. **Per visualizzare i messaggi di errore per il container** 1. È possibile ottenere un elenco di nomi di pod con il comando seguente. Se non si sta utilizzando il namespace predefinito, utilizzare `-n NAMESPACE`. ``` kubectl get pods ``` 1. Per descrivere il Pod, nel comando seguente, *PODID* usa l'ID Pod dei Pod che hai trovato nel passaggio precedente. Se non si sta utilizzando lo spazio dei nomi predefinito, utilizzare `-n NAMESPACE`. ``` kubectl describe pod/PODID ``` **Come visualizzare gli errori per l'ASCP** + Per trovare maggiori informazioni nei log del provider, nel comando seguente, *PODID* usa l'ID del Pod *csi-secrets-store-provider-aws*. ``` kubectl -n kube-system get pods kubectl -n kube-system logs pod/PODID ``` # Usa AWS Secrets and Configuration Provider CSI con IAM Roles for Service Accounts (IRSA) **Topics** + [Prerequisiti](#prerequisites) + [Configurazione del controllo degli accessi](#integrating_ascp_irsa_access) + [Identificazione dei segreti montare](#integrating_ascp_irsa_mount) + [Risoluzione dei problemi](#integrating_ascp_irsa_trouble) ## Prerequisiti + Cluster Amazon EKS (versione 1.17 o successiva) + Accesso AWS CLI e cluster Amazon EKS tramite `kubectl` ## Configurazione del controllo degli accessi L'ASCP recupera il Pod Identity di Amazon EKS e lo scambia con il ruolo IAM. Le autorizzazioni vengono impostate in una policy IAM per quel ruolo IAM. Quando ASCP assume il ruolo IAM, ottiene l'accesso ai segreti che hai autorizzato. Altri container non possono accedere ai segreti a meno che non vengano associati anche al ruolo IAM. **Per consentire al tuo Amazon EKS Pod di accedere ai segreti in Secrets Manager** 1. Crea una politica di autorizzazioni che conceda `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` autorizzi i segreti a cui il Pod deve accedere. Per un esempio di policy, consulta [Esempio: autorizzazione a leggere e descrivere singoli segreti](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe). 1. Crea un provider OpenID Connect (OIDC) IAM per il cluster se non ne è già presente uno. Per ulteriori informazioni, consulta [Crea un provider IAM OIDC per il tuo cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) nella *Guida per l'utente di Amazon EKS*. 1. Crea un [Ruolo IAM per l'account del servizio](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) e collega la policy ad esso. Per ulteriori informazioni, consulta [Crea un ruolo IAM per un account del servizio](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) nella *Guida per l'utente di Amazon EKS*. 1. Se utilizzi un cluster Amazon EKS privato, assicurati che il VPC in cui si trova il cluster abbia un AWS STS endpoint. Per informazioni sulla creazione di un endpoint, consulta [Endpoint VPC di interfaccia](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) nella * Guida per l'utente AWS Identity and Access Management *. ## Identificazione dei segreti montare Per determinare quali segreti l'ASCP monta in Amazon EKS come file sul file system, è necessario creare un file [SecretProviderClass](ascp-examples.md#ascp-examples-secretproviderclass) YAML. `SecretProviderClass`Elenca i segreti da montare e il nome del file con cui montarli. Il `SecretProviderClass` deve trovarsi nello stesso namespace del pod Amazon EKS a cui fa riferimento. ### Monta i segreti come file [Le seguenti istruzioni mostrano come montare i segreti come file utilizzando file YAML di esempio .yaml e [ExampleSecretProviderClass.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml). ExampleDeployment](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleDeployment-IRSA.yaml) **Per montare segreti in Amazon EKS** 1. Applica il `SecretProviderClass` al pod: ``` kubectl apply -f ExampleSecretProviderClass.yaml ``` 1. Distribuisci il pod: ``` kubectl apply -f ExampleDeployment.yaml ``` 1. L'ASCP monta i file. ## Risoluzione dei problemi È possibile visualizzare la maggior parte degli errori descrivendo l'implementazione del pod. **Per visualizzare i messaggi di errore per il container** 1. È possibile ottenere un elenco di nomi di pod con il comando seguente. Se non si sta utilizzando il namespace predefinito, utilizzare `-n nameSpace`. ``` kubectl get pods ``` 1. Per descrivere il Pod, nel comando seguente, *podId* usa l'ID Pod dei Pod che hai trovato nel passaggio precedente. Se non si sta utilizzando lo spazio dei nomi predefinito, utilizzare `-n nameSpace`. ``` kubectl describe pod/podId ``` **Come visualizzare gli errori per l'ASCP** + Per trovare maggiori informazioni nei log del provider, nel comando seguente, *podId* usa l'ID del Pod *csi-secrets-store-provider-aws*. ``` kubectl -n kube-system get pods kubectl -n kube-system logs Pod/podId ``` + **Verifica che il `SecretProviderClass` sia installato:** ``` kubectl get crd secretproviderclasses.secrets-store.csi.x-k8s.io ``` Questo comando deve restituire informazioni sulla definizione delle risorse personalizzate `SecretProviderClass`. + **Verifica che l' SecretProviderClass oggetto sia stato creato.** ``` kubectl get secretproviderclass SecretProviderClassName -o yaml ``` # AWS Segreti ed esempi di codice del Configuration Provider ## Esempi di autenticazione e controllo degli accessi ASCP ### Esempio: policy IAM che consente al servizio Amazon EKS Pod Identity (pods.eks.amazonaws.com) di assumere il ruolo e contrassegnare la sessione: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "pods.eks.amazonaws.com" }, "Action": [ "sts:AssumeRole", "sts:TagSession" ] } ] } ``` ------ ## SecretProviderClass Puoi utilizzare YAML per descrivere quali segreti montare in Amazon EKS utilizzando l'ASCP. Per alcuni esempi, consulta [SecretProviderClass utilizzo](#ascp-scenarios-secretproviderclass). ### SecretProviderClass Struttura YAML ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: name spec: provider: aws parameters: region: failoverRegion: pathTranslation: usePodIdentity: preferredAddressType: objects: ``` Il campo parametri contiene i dettagli della richiesta di montaggio: **region** (Facoltativo) Il Regione AWS segreto. Se non utilizzi questo campo, l'ASCP cerca la Regione dall'annotazione sul nodo. Questa ricerca aggiunge un sovraccarico alle richieste di montaggio, quindi consigliamo di fornire la Regione per i cluster che utilizzano un numero elevato di pod. Se specifichi anche la `failoverRegion`, l'ASCP tenta di recuperare il segreto da entrambe le Regioni. Se una delle Regioni restituisce un errore 4xx, ad esempio per un problema di autenticazione, l'ASCP non installa nessuno dei due segreti. Se il segreto viene recuperato correttamente da `region`, l'ASCP monta tale valore del segreto. Se il segreto non viene recuperato correttamente da `region`, ma viene correttamente recuperato da `failoverRegion`, l'ASCP monta tale valore del segreto. **failoverRegion** (Facoltativo) Se si include questo campo, l'ASCP tenta di recuperare il segreto dalle Regioni definite in`region` e in questo campo. Se una delle Regioni restituisce un errore 4xx, ad esempio per un problema di autenticazione, l'ASCP non installa nessuno dei due segreti. Se il segreto viene recuperato correttamente da `region`, l'ASCP monta tale valore del segreto. Se il segreto non viene recuperato correttamente da `region`, ma viene correttamente recuperato da `failoverRegion`, l'ASCP monta tale valore del segreto. Per un esempio su come utilizzare questo campo, consulta la sezione [Failover segreto in più regioni](#multi-region-failover). **pathTranslation** (Facoltativo) Un singolo carattere di sostituzione da utilizzare se il nome del file in Amazon EKS conterrà il carattere separatore di percorso, come barra (/) su Linux. L'ASCP non è in grado di creare un file montato che contiene un carattere separatore di percorso. Invece, l'ASCP sostituisce il carattere separatore di percorso con un carattere diverso. Se non utilizzi questo campo, il carattere sostitutivo è il carattere di sottolineatura (\$1), quindi ad esempio, `My/Path/Secret` monta come `My_Path_Secret`. Per impedire la sostituzione dei caratteri, immettere la stringa `False`. **usePodIdentity** (Facoltativo) Determina l'approccio di autenticazione. Se non specificato, il valore predefinito è ruoli IAM per gli account di servizio (IRSA). + Per utilizzare EKS Pod Identity, utilizza uno qualsiasi di questi valori: `"true"`", `"True"`, `"TRUE"`, `"t"` o `"T"`. + Per utilizzare in modo esplicito IRSA, imposta uno qualsiasi dei seguenti valori: `"false"`, `"False"`, `"FALSE"`, `"f"`, or `"F"`"=. **preferredAddressType** (Facoltativo) Specifica il tipo di indirizzo IP preferito per la comunicazione con gli endpoint dell'agente Pod Identity. Il campo è applicabile solo quando si utilizza la funzionalità EKS Pod Identity e verrà ignorato, quando si utilizzano i ruoli IAM per gli account di servizio. I valori non fanno distinzione tra maiuscole e minuscole. I valori validi sono: + `"ipv4"`, `"IPv4"` «, oppure `"IPV4"` — Forza l'uso dell' IPv4 endpoint Pod Identity Agent + `"ipv6"`,`"IPv6"`, o `"IPV6"` — Forza l'uso dell'endpoint Pod Identity Agent IPv6 + non specificato: utilizza la selezione automatica degli endpoint, provando prima l' IPv4 endpoint e ritornando all' IPv6 endpoint se fallisce IPv4 **objects** Una stringa contenente una dichiarazione YAML dei segreti da montare. Si consiglia di utilizzare una stringa multiriga YAML o un carattere pipe (\$1). **objectName** Obbligatorio. Speciifica il nome del segreto o del parametro da recuperare. Per Secrets Manager questo è il parametro [https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters) e può essere sia il nome descrittivo sia l'ARN completo del segreto. Per SSM Parameter Store, questo è il [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters)parametro e può essere il nome o l'ARN completo del parametro. **objectType** Obbligatorio se non si utilizza un ARN di Secrets Manager per `objectName`. Può essere `secretsmanager` o `ssmparameter`. **objectAlias** (Facoltativo) Il nome file del segreto nel pod Amazon EKS. Se non indichi questo campo, `objectName` viene visualizzato come nome del file. **Autorizzazione del file** (Facoltativo) La stringa ottale a 4 cifre che specifica l'autorizzazione del file con cui eseguire il montaggio segreto. Se non specifichi questo campo, il valore predefinito sarà. `"0644"` **objectVersion** (Facoltativo) L'ID di versione del segreto. Non è consigliato perché è necessario aggiornare l'ID di versione ogni volta che si aggiorna il segreto. Per impostazione predefinita viene utilizzata la versione più recente. Se includi un `failoverRegion`, questo campo rappresenta l'`objectVersion` primario. **objectVersionLabel** (Facoltativo) L'alias per la versione. Il valore predefinito è la versione più recente AWSCURRENT. Per ulteriori informazioni, consulta [Versioni segrete](whats-in-a-secret.md#term_version). Se includi un `failoverRegion`, questo campo rappresenta l'`objectVersionLabel` primario. **jmesPath** (Facoltativo) Una mappa delle chiavi nel segreto per i file da montare in Amazon EKS. Per utilizzare questo campo, il valore del segreto deve essere in formato JSON. Se si utilizza questo campo, è necessario includere i sottocampi `path` e `objectAlias`. **path** Una chiave da una coppia chiave-valore nel JSON del valore segreto. Se il campo contiene un trattino, usa le virgolette singole per evitarlo, ad esempio: `path: '"hyphenated-path"'` **objectAlias** Il nome del file da montare nel pod Amazon EKS. Se il campo contiene un trattino, usa le virgolette singole per evitarlo, ad esempio: `objectAlias: '"hyphenated-alias"'` **Autorizzazione del file** (Facoltativo) La stringa ottale a 4 cifre che specifica l'autorizzazione del file con cui eseguire il montaggio segreto. Se non si specifica questo campo, verrà utilizzata per impostazione predefinita l'autorizzazione al file dell'oggetto principale. **failoverObject** (Facoltativo) Se specifichi questo campo, l'ASCP tenta di recuperare sia il segreto specificato nel campo primario `objectName` che il segreto specificato nel sottocampo `failoverObject` `objectName`. Se uno dei due restituisce un errore 4xx, ad esempio per un problema di autenticazione, l'ASCP non installa nessuno dei due segreti. Se il segreto viene recuperato con successo dall'`objectName` primario, l'ASCP monta tale valore del segreto. Se il segreto non viene recuperato correttamente dall'`objectName` primario, ma viene recuperato con successo dall'`objectName` di failover, l'ASCP installa tale valore del segreto. Se si include questo campo, è necessario includere il campo `objectAlias`. Per un esempio su come utilizzare questo campo, consulta la sezione [Failover su un segreto diverso](#failover-secret). In genere, si utilizza questo campo quando il segreto di failover non è una replica. Per un esempio su come specificare una replica, consulta la sezione [Failover segreto in più regioni](#multi-region-failover). **objectName** Il nome o l'ARN completo del segreto di failover. Se utilizzi un ARN, la Regione nell'ARN deve corrispondere al campo `failoverRegion`. **objectVersion** (Facoltativo) L'ID di versione del segreto. Deve corrispondere all'`objectVersion` primaria. Non è consigliato perché è necessario aggiornare l'ID di versione ogni volta che si aggiorna il segreto. Per impostazione predefinita viene utilizzata la versione più recente. **objectVersionLabel** (Facoltativo) L'alias per la versione. L'impostazione predefinita è la versione più recente AWSCURRENT. Per ulteriori informazioni, consulta [Versioni segrete](whats-in-a-secret.md#term_version). ### Crea una SecretProviderClass configurazione di base per montare segreti nei tuoi Amazon EKS Pods. ------ #### [ Pod Identity ] SecretProviderClass per utilizzare un segreto nello stesso cluster Amazon EKS: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets-manager spec: provider: aws parameters: objects: | - objectName: "mySecret" objectType: "secretsmanager" usePodIdentity: "true" ``` ------ #### [ IRSA ] ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: deployment-aws-secrets spec: provider: aws parameters: objects: | - objectName: "MySecret" objectType: "secretsmanager" ``` ------ ### SecretProviderClass utilizzo Usa questi esempi per creare SecretProviderClass configurazioni per diversi scenari. #### Esempio: montaggio di segreti per nome o ARN Questo esempio mostra come montare tre diversi tipi di segreti: + Un segreto specificato dall'ARN completo + Un segreto specificato per nome + Una versione specifica di un segreto ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets spec: provider: aws parameters: objects: | - objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret2-d4e5f6" - objectName: "MySecret3" objectType: "secretsmanager" - objectName: "MySecret4" objectType: "secretsmanager" objectVersionLabel: "AWSCURRENT" ``` #### Esempio: monta coppie chiave-valore da un segreto Questo esempio mostra come montare coppie chiave-valore specifiche da un segreto in formato JSON: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets spec: provider: aws parameters: objects: | - objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret-a1b2c3" jmesPath: - path: username objectAlias: dbusername - path: password objectAlias: dbpassword ``` #### Esempio: monta i segreti tramite l'autorizzazione del file Questo esempio mostra come montare un segreto con un'autorizzazione specifica per il file ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets spec: provider: aws parameters: objects: | - objectName: "mySecret" objectType: "secretsmanager" filePermission: "0600" jmesPath: - path: username objectAlias: dbusername filePermission: "0400" ``` #### Esempio: esempi di configurazione di failover Questi esempi mostrano come configurare il failover per i segreti. ##### Failover segreto in più regioni Questo esempio mostra come configurare il failover automatico per un segreto replicato su più regioni: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets spec: provider: aws parameters: region: us-east-1 failoverRegion: us-east-2 objects: | - objectName: "MySecret" ``` ##### Failover su un segreto diverso Questo esempio mostra come configurare il failover su un segreto diverso (non su una replica): ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-secrets spec: provider: aws parameters: region: us-east-1 failoverRegion: us-east-2 objects: | - objectName: "arn:aws:secretsmanager:us-east-1:777788889999:secret:MySecret-a1b2c3" objectAlias: "MyMountedSecret" failoverObject: - objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MyFailoverSecret-d4e5f6" ``` ## Risorse aggiuntive Per ulteriori informazioni su come utilizzare ASCP con Amazon EKS, consulta le seguenti risorse: + [Utilizzo di Pod Identity con Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html) + [Utilizzo di AWS Secrets and Configuration Provider](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_ascp_csi.html) + [AWS Secrets Store CSI Driver attivo GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)