• La AWS Systems Manager CloudWatch dashboard non sarà più disponibile dopo il 30 aprile 2026. I clienti possono continuare a utilizzare la CloudWatch console Amazon per visualizzare, creare e gestire le proprie CloudWatch dashboard Amazon, proprio come fanno oggi. Per ulteriori informazioni, consulta la [documentazione di Amazon CloudWatch Dashboard](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html). 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à. # Utilizza i parametri Parameter Store in Amazon Elastic Kubernetes Service Utilizzare i segreti Gestione dei segreti AWS in Amazon Elastic Kubernetes Service Per mostrare i parametri da Parameter Store, uno strumento di AWS Systems Manager, come file montati in pod Amazon EKS, è possibile utilizzare l'AWS Secrets and Configuration Provider per il driver CSI di Kubernetes Secrets Store. ASCP funziona con la versione 1.17 o quella successiva del servizio Amazon Elastic Kubernetes che esegue un gruppo di nodi Amazon EC2. I gruppi di nodi AWS Fargate non sono supportati. Con ASCP, è possibile archiviare e gestire il parametro in Parameter Store e recuperarlo tramite i carichi di lavoro in esecuzione su Amazon EKS. Se il tuo parametro contiene molteplici 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 segreti Gestione dei segreti AWS. 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 i ruoli IAM per gli account di servizio (IRSA) ti consente di montare parametri da Parameter Store come file nei tuoi pod Amazon EKS. Questo approccio è adatto quando: + È necessario montare i parametri come file nei Pod. + 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 parametri 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 L'ASCP con il metodo Pod Identity migliora la sicurezza e semplifica la configurazione per l'accesso ai parametri in Parameter Store. 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: + Versione di Amazon EKS: Pod Identity richiede la versione 1.24 o quella successiva di Amazon EKS, mentre il driver CSI funziona con la versione 1.17 o quella successiva di Amazon EKS. + 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 parametri Parameter Store e segreti da Gestione dei segreti AWS 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 tramite la modifica del valore `objectType` da `secretsmanager` a `ssmparameter`. Durante l'installazione, puoi configurare l'ASCP per utilizzare un endpoint FIPS. Per un elenco degli endpoint di Systems Manager, consulta gli [endpoint del servizio di Systems Manager](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) nella *Riferimenti generali di Amazon Web Services*. **Installazione dell'ASCP con l'utilizzo di Helm** 1. Per assicurarti che il repository punti al grafico più recente, utilizza `helm repo update.` 1. Aggiungi il grafico dei driver CSI di Secrets Store. ``` helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts ``` 1. Installare il grafico. 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"}'` ``` helm install -n kube-system csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver ``` 1. Aggiungi il grafico ASCP. ``` helm repo add aws-secrets-manager https://aws.github.io/secrets-store-csi-driver-provider-aws ``` 1. Installare il grafico. Per utilizzare un endpoint FIPS, aggiungi il seguente flag: `--set useFipsEndpoint=true` ``` helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws ``` **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`. Sostituiscilo *default placeholder text* con il tuo ID pod: ``` kubectl -n kube-system get pods ``` ``` kubectl -n kube-system logs pod/pod-id ``` 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 Il driver CSI di 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 Integra ASCP 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 AWS Identity and Access Management (IAM) per Amazon EKS durante il recupero di parametri AWS Systems Manager Parameter Store o segreti da Secrets Manager. 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 parametri 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` + (Facoltativo) Accesso a due account Account AWS per l'accesso su più account ## Installazione dell'agente Amazon EKS Pod Identity Installazione dell'agente 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 agente Pod Identity sul tuo cluster. *default placeholder text *Sostituiscili con i tuoi valori: ``` eksctl create addon \ --name eks-pod-identity-agent \ --cluster clusterName \ --region region ``` ## Configura ASCP con Pod Identity Configurazione di Pod Identity 1. Crea una policy di autorizzazioni che conceda l'autorizzazione `ssm:GetParameters` e `ssm:DescribeParameters` ai parametri a cui il pod deve accedere. 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. *default placeholder text *Sostituiscili con i tuoi valori: ``` 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` che specifica quali parametri o segreti montare nel pod: ``` kubectl apply -f 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. Distribuisci il pod che monta i parametri o i segreti in `/mnt/secrets-store`: ``` kubectl apply -f 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 parametro o il segreto siano montati correttamente, eseguire il comando riportato di seguito. Sostituiscili *default placeholder text * con i tuoi valori: ``` kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MyParameter ``` **Per configurare Amazon EKS Pod Identity per l'accesso ai parametri in Parameter Store** 1. Crea una policy di autorizzazioni che conceda l'autorizzazione `ssm:GetParameters` e `ssm:DescribeParameters` ai parametri a cui il pod deve accedere. 1. Crea un parametro inParameter Store, se non ne hai già uno. Per informazioni, consulta [Creazione di parametri Parameter Store in Systems Manager](sysman-paramstore-su-create.md). ## 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, *pod-id* 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/pod-id ``` **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/pod-id ``` # Usa AWS Secrets and Configuration Provider CSI con IAM Roles for Service Accounts (IRSA) Integra ASCP con Pod Identity per Amazon EKS **Topics** + [ ## Prerequisiti ](#prerequisites) + [ ## Configurazione del controllo degli accessi ](#integrating_ascp_irsa_access) + [ ## Identifica i parametri da 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 l'ASCP assume il ruolo IAM, ottiene l'accesso ai parametri autorizzati. Altri container non possono accedere ai parametri a meno che non vengano associati anche al ruolo IAM. **Concedere al pod Amazon EKS l'accesso ai parametri in Parameter Store** 1. Crea una policy di autorizzazioni che conceda l'autorizzazione `ssm:GetParameters` e `ssm:DescribeParameters` ai parametri a cui il pod deve accedere. 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 *. ## Identifica i parametri da montare Per determinare quali parametri monta l'ASCP in Amazon EKS come file sul file system, è necessario creare un file [SecretProviderClass](ascp-examples.md#ascp-examples-secretproviderclass) YAML. Il `SecretProviderClass` elenca i parametri 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 parametri come file [https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml) **Per montare i parametri 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 name-space`. ``` kubectl get pods ``` 1. Per descrivere il Pod, nel comando seguente, *pod-id* 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/pod-id ``` **Come visualizzare gli errori per l'ASCP** + Per trovare maggiori informazioni nei log del provider, nel comando seguente, *pod-id* usa l'ID del Pod *csi-secrets-store-provider-aws*. ``` kubectl -n kube-system get pods kubectl -n kube-system logs Pod/pod-id ``` + **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 ASCP ## 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 parametri 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 parametro. 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 il `failoverRegion`, l'ASCP tenta di recuperare il parametrp da entrambe le Regioni. Se una delle Regioni restituisce un errore `4xx`, ad esempio per un problema di autenticazione, l'ASCP non monta nessuno dei due parametri. Se il parametro viene recuperato correttamente da `region```, l'ASCP monta quel valore del parametro. Se il parametro non viene recuperato correttamente da `region`, ma viene correttamente recuperato da `failoverRegion`, l'ASCP monta quel valore del parametro. **`failoverRegion`** (Facoltativo) Se si include questo campo, l'ASCP tenta di recuperare il parametro 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 monta nessuno dei due parametri. Se il parametro viene recuperato correttamente da `region`, l'ASCP monta quel valore del parametro. Se il parametro non viene recuperato correttamente da `region`, ma viene correttamente recuperato da `failoverRegion`, l'ASCP monta quel valore del parametro. Per un esempio su come utilizzare questo campo, consulta la sezione [Failover multiregionale dei parametri](#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/Parameter` monta come `My_Path_Parameter`. 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' IPv6endpoint 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. Specifica il nome del parametro o del segreto da recuperare. PerParameter 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) del parametro e può essere sia il nome che l'ARN completo del parametro. 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. **objectType** Obbligatorio se non si utilizza un ARN di Secrets Manager per `objectName`. Per Parameter Store, utilizza `ssmparameter`. Per Secrets Manager, utilizza `secretsmanager`. **objectAlias** (Facoltativo) Il nome file del segreto nel pod Amazon EKS. Se non indichi questo campo, `objectName` viene visualizzato come nome del file. **objectVersion** (Facoltativo) Il numero ID del parametro. Non è consigliato, perché è necessario aggiornare l'ID di versione ogni volta che si aggiorna il parametro. 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`. Se includi un `failoverRegion`, questo campo rappresenta l'`objectVersionLabel` primario. **jmesPath** (Facoltativo) Una mappa delle chiavi nel parametro per i file da montare in Amazon EKS. Per utilizzare questo campo, il valore del parametro deve essere in formato JSON. L'esempio seguente mostra l'aspetto di un parametro codificato JSON. ``` { "username" : "myusername", "password" : "mypassword" } ``` Le chiavi sono `username` e `password`. Il valore associato a `username` è `myusername` e il valore associato a `password` è `mypassword`. Se si utilizza questo campo, è necessario includere i sottocampi `path` e `objectAlias`. **path** Una chiave di una coppia chiave-valore nel JSON del valore del parametro. 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"'` **`failoverObject`** (Facoltativo) Se specifichi questo campo, l'ASCP tenta di recuperare sia il parametro specificato nel campo `objectName` primario che quello specificato nel sottocampo `failoverObject` `objectName`. Se uno dei due restituisce un errore `4xx`, ad esempio per un problema di autenticazione, l'ASCP non monta nessuno dei due parametri. Se si riesce a recuperare il parametro dal `objectName` primario, l'ASCP monta quel valore del parametro. Se il parametro non viene recuperato correttamente dal `objectName` primario, ma viene recuperato correttamente dal `objectName` di failover, l'ASCP monta quel valore del parametro. Se si include questo campo, è necessario includere il campo `objectAlias`. Per un esempio su come utilizzare questo campo, consulta la sezione [Failover su un parametro diverso](#failover-parameter). In genere, si utilizza questo campo quando il parametro di failover non è una replica. Per un esempio su come specificare una replica, consulta la sezione [Failover multiregionale dei parametri](#multi-region-failover). **objectName** Il nome o l'ARN completi del parametro di failover. Se utilizzi un ARN, la Regione nell'ARN deve corrispondere al campo `failoverRegion`. **objectVersion** (Facoltativo) Il numero ID del parametro. Deve corrispondere all'`objectVersion` primaria. Non è consigliato, perché è necessario aggiornare l'ID di versione ogni volta che si aggiorna il parametro. Per impostazione predefinita viene utilizzata la versione più recente. **objectVersionLabel** (Facoltativo) L'alias per la versione. Il valore predefinito è la versione più recente `AWSCURRENT`. ### Crea una SecretProviderClass configurazione di base per montare i parametri nei tuoi Amazon EKS Pods. ------ #### [ Pod Identity ] SecretProviderClass per utilizzare un parametro nello stesso cluster Amazon EKS: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-parameter-store spec: provider: aws parameters: objects: | - objectName: "MyParameter" objectType: "ssmparameter" usePodIdentity: "true" ``` ------ #### [ IRSA ] ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: deployment-aws-parameter spec: provider: aws parameters: objects: | - objectName: "MyParameter" objectType: "ssmparameter" ``` ------ ### SecretProviderClass utilizzo Usa questi esempi per creare configurazioni `SecretProviderClass` per diversi scenari. #### Esempio: montaggio di parametri per nome o ARN Questo esempio mostra come montare tre diversi tipi di parametri: + Un parametro specificato dall'ARN completo + Un parametro specificato dal nome + Una versione parametrica di un segreto ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-parameters spec: provider: aws parameters: objects: | - objectName: "arn:aws:ssm:us-east-2:777788889999:parameter:MyParameter2-d4e5f6" - objectName: "MyParameter3" objectType: "ssmparameter" - objectName: "MyParameter4" objectType: "ssmparameter" objectVersionLabel: "AWSCURRENT" ``` #### Esempio: montaggio di coppie chiave-valore da un parametro Questo esempio mostra come montare coppie chiave-valore specifiche da un parametro in formato JSON: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-parameters spec: provider: aws parameters: objects: | - objectName: "arn:aws:ssm:us-east-2:777788889999:parameter:MyParameter-a1b2c3" jmesPath: - path: username objectAlias: dbusername - path: password objectAlias: dbpassword ``` #### Esempio: esempi di configurazione di failover Questi esempi mostrano come configurare il failover per i parametri. ##### Failover multiregionale dei parametri Questo esempio mostra come configurare il failover automatico per un parametro replicato su più regioni: ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-parameters spec: provider: aws parameters: region: us-east-1 failoverRegion: us-east-2 objects: | - objectName: "MyParameter" ``` ##### Failover su un parametro diverso Questo esempio mostra come configurare il failover su un parametro diverso (non una replica): ``` apiVersion: secrets-store.csi.x-k8s.io/v1 kind: SecretProviderClass metadata: name: aws-parameters spec: provider: aws parameters: region: us-east-1 failoverRegion: us-east-2 objects: | - objectName: "arn:aws:ssm:us-east-1:777788889999:parameter:MyParameter-a1b2c3" objectAlias: "MyMountedParameter" failoverObject: - objectName: "arn:aws:ssm:us-east-2:777788889999:parameter:MyFailoverParameter-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) + [AWS Driver CSI Secrets Store attivo GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)