**Contribuisci a migliorare questa pagina** 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à. Per contribuire a questa guida per l'utente, scegli il GitHub link **Modifica questa pagina** nel riquadro destro di ogni pagina. 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à. # Informazioni su come implementare carichi di lavoro e componenti aggiuntivi su Amazon EKS I carichi di lavoro vengono implementati in container, a loro volta implementati in pod in Kubernetes. Un pod include uno o più container. In genere, uno o più pod che forniscono lo stesso servizio vengono implementati in un servizio Kubernetes. Dopo aver implementato più pod che forniscono lo stesso servizio, puoi: + [Visualizzare le informazioni sui carichi di lavoro](view-kubernetes-resources.md) in esecuzione su ogni cluster utilizzando il Console di gestione AWS. + Dimensionare verticalmente i pod verso l’alto o verso il basso con [Vertical Pod Autoscaler](vertical-pod-autoscaler.md) di Kubernetes. + Dimensionare orizzontalmente verso l’alto o verso il basso il numero di pod necessari per soddisfare la domanda con [Horizontal Pod Autoscaler](horizontal-pod-autoscaler.md) di Kubernetes. + Creare un [Network Load Balancer](network-load-balancing.md) esterno (per i pod accessibili a internet) o interno (per i pod privati) per bilanciare il traffico di rete tra i pod. Il load balancer indirizza il traffico al livello 4 del modello OSI. + Creare un [Application Load Balancer](alb-ingress.md) per bilanciare il traffico delle applicazioni tra i pod. Il load balancer di applicazione indirizza il traffico al livello 7 del modello OSI. + Se sei un nuovo utente di Kubernetes, questo argomento aiuta a [implementare un’applicazione di esempio](sample-deployment.md). + È possibile [limitare gli indirizzi IP assegnabili a un servizio](restrict-service-external-ip.md) con `externalIPs`. # Implementazione di un’applicazione esemplificativa In questa sezione, imparerai a implementare un’applicazione esemplificativa nel cluster sui nodi Linux. ## Prerequisiti + Un cluster Kubernetes esistente con almeno un nodo. Se non si dispone di un cluster Amazon EKS esistente, è possibile implementarne uno utilizzando una delle guide in [Nozioni di base su Amazon EKS](getting-started.md). + `Kubectl` installato sul computer. Per ulteriori informazioni, consulta [Impostazione di `kubectl` e `eksctl`](install-kubectl.md). + `Kubectl` configurato per comunicare con il cluster. Per ulteriori informazioni, consulta [Connettere kubectl a un cluster EKS creando un file kubeconfig](create-kubeconfig.md). + Se si prevede di implementare il carico di lavoro di esempio in Fargate, è necessario disporre di un [profilo Fargate](fargate-profile.md) che include lo stesso spazio dei nomi creato in questo tutorial, che è `eks-sample-app`, a meno che non cambi il nome. Se hai creato un cluster con una delle guide in [Nozioni di base su Amazon EKS](getting-started.md), dovrai creare un nuovo profilo o aggiungere il namespace al profilo esistente, poiché il profilo creato nelle guide introduttive non specifica il namespace utilizzato in questo tutorial. Il VPC deve disporre di almeno una sottorete privata. Sebbene molte variabili siano modificabili nei passaggi seguenti, si consiglia di modificare solo i valori delle variabili, se specificato. Con una migliore conoscenza dei pod, delle implementazioni e dei servizi Kubernetes, è possibile provare a modificare altri valori. ## Creare uno spazio dei nomi Uno spazio dei nomi consente di raggruppare le risorse in Kubernetes. Per ulteriori informazioni, consultare [Spazio dei nomi](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) nella documentazione Kubernetes. Se intendi di implementare la tua applicazione esemplificativa per [semplificare la gestione del calcolo con AWS Fargate](fargate.md), assicurati che il valore per `namespace` nel tuo [Definisci quali pod utilizzano AWS Fargate al momento di un avvio](fargate-profile.md) sia `eks-sample-app`. ``` kubectl create namespace eks-sample-app ``` ## Creazione di un’implementazione Kubernetes Creare un'implementazione Kubernetes. Questa implementazione esemplificativa estrae un’immagine container da un repository pubblico e ne implementa tre repliche (pod individuali) sul cluster. Per ulteriori informazioni, consultare la sezione [Implementazioni](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) nella documentazione Kubernetes. 1. Salva i contenuti seguenti in un file denominato `eks-sample-deployment.yaml`. I container nell’applicazione esemplificativa non utilizzano l’archiviazione di rete, ma potrebbe essere necessaria per determinate applicazioni. Per ulteriori informazioni, consulta [Utilizzo dell’archiviazione di dati delle applicazioni per il tuo cluster](storage.md). + `amd64` o `arm64` `values` nella chiave `kubernetes.io/arch` significa che l'applicazione può essere implementata su entrambe le architetture hardware (se entrambe sono presenti nel cluster). Ciò è possibile perché questa immagine è un'immagine multi-architettura, ma non tutte lo sono. È possibile determinare l’architettura hardware su cui è supportata l’immagine visualizzando i [dettagli dell’immagine](https://gallery.ecr.aws/nginx/nginx) nel repository da cui la stai estraendo. Quando si implementano immagini che non supportano un tipo di architettura hardware o che non si desidera implementare, rimuovere quel tipo ti architettura dal manifesto. Per ulteriori informazioni, consulta [Etichette, annotazioni e taint note](https://kubernetes.io/docs/reference/labels-annotations-taints/) nella documentazione Kubernetes. + `kubernetes.io/os: linux` `nodeSelector` significa che se avessi nodi Linux e Windows, ad esempio nel cluster, l'immagine verrebbe implementata solo sui nodi Linux. Per ulteriori informazioni, consulta [Etichette, annotazioni e taint note](https://kubernetes.io/docs/reference/labels-annotations-taints/) nella documentazione Kubernetes. ``` apiVersion: apps/v1 kind: Deployment metadata: name: eks-sample-linux-deployment namespace: eks-sample-app labels: app: eks-sample-linux-app spec: replicas: 3 selector: matchLabels: app: eks-sample-linux-app template: metadata: labels: app: eks-sample-linux-app spec: affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: kubernetes.io/arch operator: In values: - amd64 - arm64 containers: - name: nginx image: public.ecr.aws/nginx/nginx:1.23 ports: - name: http containerPort: 80 imagePullPolicy: IfNotPresent nodeSelector: kubernetes.io/os: linux ``` 1. Applicare il manifesto di implementazione al cluster. ``` kubectl apply -f eks-sample-deployment.yaml ``` ## Crea un servizio. Un servizio consente di accedere a tutte le repliche tramite un unico indirizzo IP o nome. Per ulteriori informazioni, consultare la sezione [Servizio](https://kubernetes.io/docs/concepts/services-networking/service/) nella documentazione Kubernetes. Anche se non implementato nell’applicazione esemplificativa, se si dispone di applicazioni che devono interagire con altri servizi AWS, ti consigliamo di creare account di servizio Kubernetes per i tuoi pod e di associarli agli account IAM AWS. Specificando gli account di servizio, è possibile che i pod dispongano delle autorizzazioni minime necessarie per interagire con altri servizi. Per ulteriori informazioni, consulta [Ruoli IAM per gli account di servizio](iam-roles-for-service-accounts.md). 1. Salva i contenuti seguenti in un file denominato `eks-sample-service.yaml`. Kubernetes assegna al servizio il proprio indirizzo IP accessibile solo dall'interno del cluster. Per accedere al servizio dall'esterno del cluster, implementare il [controller del load balancer AWS](aws-load-balancer-controller.md) per bilanciare il carico dell'[applicazione](alb-ingress.md) o del traffico di [rete](network-load-balancing.md) verso il servizio. ``` apiVersion: v1 kind: Service metadata: name: eks-sample-linux-service namespace: eks-sample-app labels: app: eks-sample-linux-app spec: selector: app: eks-sample-linux-app ports: - protocol: TCP port: 80 targetPort: 80 ``` 1. Applicare il manifesto del servizio al cluster. ``` kubectl apply -f eks-sample-service.yaml ``` ## Esame delle risorse create 1. Visualizzare tutte le risorse nello spazio dei nomi `eks-sample-app`. ``` kubectl get all -n eks-sample-app ``` Di seguito viene riportato un output di esempio: ``` NAME READY STATUS RESTARTS AGE pod/eks-sample-linux-deployment-65b7669776-m6qxz 1/1 Running 0 27m pod/eks-sample-linux-deployment-65b7669776-mmxvd 1/1 Running 0 27m pod/eks-sample-linux-deployment-65b7669776-qzn22 1/1 Running 0 27m NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/eks-sample-linux-service ClusterIP 10.100.74.8 80/TCP 32m NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/eks-sample-linux-deployment 3/3 3 3 27m NAME DESIRED CURRENT READY AGE replicaset.apps/eks-sample-linux-deployment-776d8f8fd8 3 3 3 27m ``` Nell'output, è possibile visualizzare il servizio e l'implementazione specificati nel manifesto di esempio implementato nei passaggi precedenti. Verranno mostrati anche tre pod. Questo perché `3` `replicas` sono state specificate nel manifesto di esempio. Per ulteriori informazioni sui pod, consulta [Pod](https://kubernetes.io/docs/concepts/workloads/pods/pod/) nella documentazione Kubernetes. Kubernetes crea automaticamente la risorsa `replicaset`, anche se non è specificato nei manifesti esemplificativi. Per ulteriori informazioni su `ReplicaSets`, consultare [ReplicaSet](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/) nella documentazione Kubernetes. **Nota** Kubernetes mantiene il numero di repliche specificate nel manifesto. Se si tratta di un’implementazione di produzione e si desidera che Kubernetes scali orizzontalmente il numero di repliche e scali verticalmente le risorse di calcolo per i pod, utilizza [Scale pod deployments with Horizontal Pod Autoscaler](horizontal-pod-autoscaler.md) e [Adjust pod resources with Vertical Pod Autoscaler](vertical-pod-autoscaler.md) per fare ciò. 1. Visualizzare i dettagli del servizio implementato. ``` kubectl -n eks-sample-app describe service eks-sample-linux-service ``` Di seguito viene riportato un output di esempio: ``` Name: eks-sample-linux-service Namespace: eks-sample-app Labels: app=eks-sample-linux-app Annotations: Selector: app=eks-sample-linux-app Type: ClusterIP IP Families: IP: 10.100.74.8 IPs: 10.100.74.8 Port: 80/TCP TargetPort: 80/TCP Endpoints: 192.168.24.212:80,192.168.50.185:80,192.168.63.93:80 Session Affinity: None Events: ``` Nell’output precedente, il valore per `IP:` è un indirizzo IP univoco che può essere raggiunto da qualsiasi nodo o pod all’interno del cluster, ma non può essere raggiunto dall’esterno del cluster. I valori per `Endpoints` sono indirizzi IP assegnati all’interno del VPC ai pod che fanno parte del servizio. 1. Visualizza i dettagli di uno dei pod elencati nell'output al momento della [visualizzazione dello spazio dei nomi](#sample-app-view-namespace) in un passaggio precedente. Sostituisci *776d8f8fd8-78w66* con il valore restituito per uno dei pod. ``` kubectl -n eks-sample-app describe pod eks-sample-linux-deployment-65b7669776-m6qxz ``` Output esemplificativo abbreviato ``` Name: eks-sample-linux-deployment-65b7669776-m6qxz Namespace: eks-sample-app Priority: 0 Node: ip-192-168-45-132.us-west-2.compute.internal/192.168.45.132 [...] IP: 192.168.63.93 IPs: IP: 192.168.63.93 Controlled By: ReplicaSet/eks-sample-linux-deployment-65b7669776 [...] Conditions: Type Status Initialized True Ready True ContainersReady True PodScheduled True [...] Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal Scheduled 3m20s default-scheduler Successfully assigned eks-sample-app/eks-sample-linux-deployment-65b7669776-m6qxz to ip-192-168-45-132.us-west-2.compute.internal [...] ``` Nell’output precedente, il valore per `IP:` è un IP univoco assegnato al pod dall’intervallo CIDR assegnato alla sottorete in cui si trova il nodo. Se si preferisce che ai pod vengano assegnati indirizzi IP da blocchi CIDR diversi, è possibile modificare il comportamento di default. Per ulteriori informazioni, consulta [Implementazione dei pod in sottoreti alternative con reti personalizzate](cni-custom-network.md). È anche possibile vedere come il pianificatore Kubernetes abbia pianificato il pod sul `Node` con l’indirizzo IP *192.168.45.132*. **Suggerimento** Anziché utilizzare la riga di comando, è possibile visualizzare molti dettagli su pod, servizi, implementazioni e altre risorse Kubernetes nella Console di gestione AWS. Per ulteriori informazioni, consulta [Visualizza le risorse Kubernetes nel Console di gestione AWS](view-kubernetes-resources.md). ## Eseguire una shell su un pod 1. Esegui una shell sul pod descritto nel passaggio precedente, sostituendo *65 b 7669776-m6qxz* con l'ID di uno dei tuoi pod. ``` kubectl exec -it eks-sample-linux-deployment-65b7669776-m6qxz -n eks-sample-app -- /bin/bash ``` 1. Dalla shell del pod, visualizzare l’output dal server Web installato con l’implementazione in una fase precedente. È necessario specificare solo il nome del servizio. Ciò è risolto sull’indirizzo IP del servizio da CoreDNS, implementato con un cluster Amazon EKS, per impostazione predefinita. ``` curl eks-sample-linux-service ``` Di seguito viene riportato un output di esempio: ``` Welcome to nginx! [...] ``` 1. Dalla shell del pod, visualizza il server DNS per il pod. ``` cat /etc/resolv.conf ``` Di seguito viene riportato un output di esempio: ``` nameserver 10.100.0.10 search eks-sample-app.svc.cluster.local svc.cluster.local cluster.local us-west-2.compute.internal options ndots:5 ``` Nell'output precedente, `10.100.0.10` viene assegnato automaticamente come `nameserver` per tutti i pod implementati nel cluster. 1. Disconnettersi dal pod digitando `exit`. 1. Una volta terminato l’uso dell’applicazione esemplificativa, sarà possibile rimuovere il namespace, il servizio e l’implementazione esemplificativa con il seguente comando. ``` kubectl delete namespace eks-sample-app ``` ## Fasi successive Dopo aver implementato l’applicazione esemplificativa, potresti provare a svolgere alcune delle seguenti esercitazioni: + [Esegui il routing del traffico di applicazioni e HTTP con Application Load Balancer](alb-ingress.md) + [Esegui il routing del traffico TCP e UDP con Network Load Balancer](network-load-balancing.md) # Implementazione di un’applicazione esemplificativa su Windows In questa sezione, imparerai a implementare un’applicazione esemplificativa nel cluster sui nodi Windows. ## Prerequisiti + Un cluster Kubernetes esistente con almeno un nodo. Se non si dispone di un cluster Amazon EKS esistente, è possibile implementarne uno utilizzando una delle guide in [Nozioni di base su Amazon EKS](getting-started.md). Devi avere il [Supporto Windows](windows-support.md) abilitato per il cluster e almeno un nodo Windows di Amazon EC2. + `Kubectl` installato sul computer. Per ulteriori informazioni, consulta [Impostazione di `kubectl` e `eksctl`](install-kubectl.md). + `Kubectl` configurato per comunicare con il cluster. Per ulteriori informazioni, consulta [Connettere kubectl a un cluster EKS creando un file kubeconfig](create-kubeconfig.md). + Se si prevede di implementare il carico di lavoro di esempio in Fargate, è necessario disporre di un [profilo Fargate](fargate-profile.md) che include lo stesso spazio dei nomi creato in questo tutorial, che è `eks-sample-app`, a meno che non cambi il nome. Se hai creato un cluster con una delle guide in [Nozioni di base su Amazon EKS](getting-started.md), dovrai creare un nuovo profilo o aggiungere il namespace al profilo esistente, poiché il profilo creato nelle guide introduttive non specifica il namespace utilizzato in questo tutorial. Il VPC deve disporre di almeno una sottorete privata. Sebbene molte variabili siano modificabili nei passaggi seguenti, si consiglia di modificare solo i valori delle variabili, se specificato. Con una migliore conoscenza dei pod, delle implementazioni e dei servizi Kubernetes, è possibile provare a modificare altri valori. ## Creare uno spazio dei nomi Uno spazio dei nomi consente di raggruppare le risorse in Kubernetes. Per ulteriori informazioni, consultare [Spazio dei nomi](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) nella documentazione Kubernetes. Se intendi di implementare la tua applicazione esemplificativa per [semplificare la gestione del calcolo con AWS Fargate](fargate.md), assicurati che il valore per `namespace` nel tuo [Definisci quali pod utilizzano AWS Fargate al momento di un avvio](fargate-profile.md) sia `eks-sample-app`. ``` kubectl create namespace eks-sample-app ``` ## Creazione di un’implementazione Kubernetes Questa implementazione esemplificativa estrae un’immagine container da un repository pubblico e ne implementa tre repliche (pod individuali) sul cluster. Per ulteriori informazioni, consultare la sezione [Implementazioni](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) nella documentazione Kubernetes. 1. Salva i contenuti seguenti in un file denominato `eks-sample-deployment.yaml`. I container nell’applicazione esemplificativa non utilizzano l’archiviazione di rete, ma potrebbe essere necessaria per determinate applicazioni. Per ulteriori informazioni, consulta [Utilizzo dell’archiviazione di dati delle applicazioni per il tuo cluster](storage.md). + `kubernetes.io/os: windows` `nodeSelector` significa che se avessi nodi Windows e Linux, ad esempio nel cluster, l'immagine verrebbe implementata solo nei nodi Windows. Per ulteriori informazioni, consulta [Etichette, annotazioni e taint note](https://kubernetes.io/docs/reference/labels-annotations-taints/) nella documentazione Kubernetes. ``` apiVersion: apps/v1 kind: Deployment metadata: name: eks-sample-windows-deployment namespace: eks-sample-app labels: app: eks-sample-windows-app spec: replicas: 3 selector: matchLabels: app: eks-sample-windows-app template: metadata: labels: app: eks-sample-windows-app spec: affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: kubernetes.io/arch operator: In values: - amd64 containers: - name: windows-server-iis image: mcr.microsoft.com/windows/servercore:ltsc2019 ports: - name: http containerPort: 80 imagePullPolicy: IfNotPresent command: - powershell.exe - -command - "Add-WindowsFeature Web-Server; Invoke-WebRequest -UseBasicParsing -Uri 'https://dotnetbinaries.blob.core.windows.net/servicemonitor/2.0.1.6/ServiceMonitor.exe' -OutFile 'C:\\ServiceMonitor.exe'; echo '

Hello EKS!!!

' > C:\\inetpub\\wwwroot\\default.html; C:\\ServiceMonitor.exe 'w3svc'; " nodeSelector: kubernetes.io/os: windows ``` 1. Applicare il manifesto di implementazione al cluster. ``` kubectl apply -f eks-sample-deployment.yaml ``` ## Crea un servizio. Un servizio consente di accedere a tutte le repliche tramite un unico indirizzo IP o nome. Per ulteriori informazioni, consultare la sezione [Servizio](https://kubernetes.io/docs/concepts/services-networking/service/) nella documentazione Kubernetes. Anche se non implementato nell’applicazione esemplificativa, se si dispone di applicazioni che devono interagire con altri servizi AWS, ti consigliamo di creare account di servizio Kubernetes per i tuoi pod e di associarli agli account IAM AWS. Specificando gli account di servizio, è possibile che i pod dispongano delle autorizzazioni minime necessarie per interagire con altri servizi. Per ulteriori informazioni, consulta [Ruoli IAM per gli account di servizio](iam-roles-for-service-accounts.md). 1. Salva i contenuti seguenti in un file denominato `eks-sample-service.yaml`. Kubernetes assegna al servizio il proprio indirizzo IP accessibile solo dall'interno del cluster. Per accedere al servizio dall'esterno del cluster, implementare il [controller del load balancer AWS](aws-load-balancer-controller.md) per bilanciare il carico dell'[applicazione](alb-ingress.md) o del traffico di [rete](network-load-balancing.md) verso il servizio. ``` apiVersion: v1 kind: Service metadata: name: eks-sample-windows-service namespace: eks-sample-app labels: app: eks-sample-windows-app spec: selector: app: eks-sample-windows-app ports: - protocol: TCP port: 80 targetPort: 80 ``` 1. Applicare il manifesto del servizio al cluster. ``` kubectl apply -f eks-sample-service.yaml ``` ## Esame delle risorse create 1. Visualizzare tutte le risorse nello spazio dei nomi `eks-sample-app`. ``` kubectl get all -n eks-sample-app ``` Di seguito viene riportato un output di esempio: ``` NAME READY STATUS RESTARTS AGE pod/eks-sample-windows-deployment-65b7669776-m6qxz 1/1 Running 0 27m pod/eks-sample-windows-deployment-65b7669776-mmxvd 1/1 Running 0 27m pod/eks-sample-windows-deployment-65b7669776-qzn22 1/1 Running 0 27m NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/eks-sample-windows-service ClusterIP 10.100.74.8 80/TCP 32m NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/eks-sample-windows-deployment 3/3 3 3 27m NAME DESIRED CURRENT READY AGE replicaset.apps/eks-sample-windows-deployment-776d8f8fd8 3 3 3 27m ``` Nell'output, è possibile visualizzare il servizio e l'implementazione specificati nel manifesto di esempio implementato nei passaggi precedenti. Verranno mostrati anche tre pod. Questo perché `3` `replicas` sono state specificate nel manifesto di esempio. Per ulteriori informazioni sui pod, consulta [Pod](https://kubernetes.io/docs/concepts/workloads/pods/pod/) nella documentazione Kubernetes. Kubernetes crea automaticamente la risorsa `replicaset`, anche se non è specificato nei manifesti esemplificativi. Per ulteriori informazioni su `ReplicaSets`, consultare [ReplicaSet](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/) nella documentazione Kubernetes. Nota Kubernetes mantiene il numero di repliche specificate nel manifesto. Se si tratta di un’implementazione di produzione e si desidera che Kubernetes scali orizzontalmente il numero di repliche e scali verticalmente le risorse di calcolo per i pod, utilizza [Scale pod deployments with Horizontal Pod Autoscaler](horizontal-pod-autoscaler.md) e [Adjust pod resources with Vertical Pod Autoscaler](vertical-pod-autoscaler.md) per fare ciò. 1. Visualizzare i dettagli del servizio implementato. ``` kubectl -n eks-sample-app describe service eks-sample-windows-service ``` Di seguito viene riportato un output di esempio: ``` Name: eks-sample-windows-service Namespace: eks-sample-app Labels: app=eks-sample-windows-app Annotations: Selector: app=eks-sample-windows-app Type: ClusterIP IP Families: IP: 10.100.74.8 IPs: 10.100.74.8 Port: 80/TCP TargetPort: 80/TCP Endpoints: 192.168.24.212:80,192.168.50.185:80,192.168.63.93:80 Session Affinity: None Events: ``` Nell’output precedente, il valore per `IP:` è un indirizzo IP univoco che può essere raggiunto da qualsiasi nodo o pod all’interno del cluster, ma non può essere raggiunto dall’esterno del cluster. I valori per `Endpoints` sono indirizzi IP assegnati all’interno del VPC ai pod che fanno parte del servizio. 1. Visualizza i dettagli di uno dei pod elencati nell'output al momento della [visualizzazione dello spazio dei nomi](sample-deployment.md#sample-app-view-namespace) in un passaggio precedente. Sostituisci 776d8f8fd8-78w66 con il valore restituito per uno dei pod. ``` kubectl -n eks-sample-app describe pod eks-sample-windows-deployment-65b7669776-m6qxz ``` Output esemplificativo abbreviato ``` Name: eks-sample-windows-deployment-65b7669776-m6qxz Namespace: eks-sample-app Priority: 0 Node: ip-192-168-45-132.us-west-2.compute.internal/192.168.45.132 [...] IP: 192.168.63.93 IPs: IP: 192.168.63.93 Controlled By: ReplicaSet/eks-sample-windows-deployment-65b7669776 [...] Conditions: Type Status Initialized True Ready True ContainersReady True PodScheduled True [...] Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal Scheduled 3m20s default-scheduler Successfully assigned eks-sample-app/eks-sample-windows-deployment-65b7669776-m6qxz to ip-192-168-45-132.us-west-2.compute.internal [...] ``` Nell’output precedente, il valore per `IP:` è un IP univoco assegnato al pod dall’intervallo CIDR assegnato alla sottorete in cui si trova il nodo. Se si preferisce che ai pod vengano assegnati indirizzi IP da blocchi CIDR diversi, è possibile modificare il comportamento di default. Per ulteriori informazioni, consulta [Implementazione dei pod in sottoreti alternative con reti personalizzate](cni-custom-network.md). È anche possibile vedere come il pianificatore Kubernetes abbia pianificato il pod sul `Node` con l’indirizzo IP 192.168.45.132. Suggerimento Anziché utilizzare la riga di comando, è possibile visualizzare molti dettagli su pod, servizi, implementazioni e altre risorse Kubernetes nella Console di gestione AWS. Per ulteriori informazioni, consulta [Visualizza le risorse Kubernetes nel Console di gestione AWS](view-kubernetes-resources.md). ## Eseguire una shell su un pod 1. Esegui una shell sul pod descritto nel passaggio precedente, sostituendo 65 b 7669776-m6qxz con l'ID di uno dei tuoi pod. ``` kubectl exec -it eks-sample-windows-deployment-65b7669776-m6qxz -n eks-sample-app -- powershell.exe ``` 1. Dalla shell del pod, visualizzare l’output dal server Web installato con l’implementazione in una fase precedente. È necessario specificare solo il nome del servizio. Ciò è risolto sull’indirizzo IP del servizio da CoreDNS, implementato con un cluster Amazon EKS, per impostazione predefinita. ``` Invoke-WebRequest -uri eks-sample-windows-service/default.html -UseBasicParsing ``` Di seguito viene riportato un output di esempio: ``` StatusCode : 200 StatusDescription : OK Content : < h t m l > < b o d y > < b r / > < b r / > < m a r q u e e > < H 1 > H e l l o E K S ! ! ! < H 1 > < m a r q u e e > < / b o d y > < h t m l > ``` 1. Dalla shell del pod, visualizza il server DNS per il pod. ``` Get-NetIPConfiguration ``` Output abbreviato ``` InterfaceAlias : vEthernet [...] IPv4Address : 192.168.63.14 [...] DNSServer : 10.100.0.10 ``` Nell'output precedente, `10.100.0.10` viene assegnato automaticamente come il server DNS per tutti i pod implementati nel cluster. 1. Disconnettersi dal pod digitando `exit`. 1. Una volta terminato l’uso dell’applicazione esemplificativa, sarà possibile rimuovere il namespace, il servizio e l’implementazione esemplificativa con il seguente comando. ``` kubectl delete namespace eks-sample-app ``` ## Fasi successive Dopo aver implementato l’applicazione esemplificativa, potresti provare a svolgere alcune delle seguenti esercitazioni: + [Esegui il routing del traffico di applicazioni e HTTP con Application Load Balancer](alb-ingress.md) + [Esegui il routing del traffico TCP e UDP con Network Load Balancer](network-load-balancing.md) # Regolazione delle risorse del pod con Vertical Pod Autoscaler [Vertical Pod Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/vertical-pod-autoscaler) di Kubernetes regola automaticamente le prenotazioni di CPU e memoria per i pod per aiutare a “dimensionare correttamente” le applicazioni. Questo processo di adeguamento può migliorare l’utilizzo delle risorse del cluster e liberare CPU e memoria per altri pod. Questo argomento illustra come implementare Vertical Pod Autoscaler nel cluster e verificarne il funzionamento. + Il cluster Amazon EKS è già esistente. In caso contrario, consulta [Nozioni di base su Amazon EKS](getting-started.md). + Kubernetes Metrics Server è già installato. Per ulteriori informazioni, consulta [Visualizza l’utilizzo delle risorse con Kubernetes Metrics Server](metrics-server.md). + Stai utilizzando un client `kubectl` che è [configurato per comunicare con il cluster Amazon EKS](getting-started-console.md#eks-configure-kubectl). + OpenSSL `1.1.1` o versioni successive deve essere installato sul dispositivo. ## Implementazione di Vertical Pod Autoscaler In questa sezione, verrà implementato Vertical Pod Autoscaler nel cluster. 1. Aprire una finestra del terminale e passare a una directory in cui si desidera scaricare il codice sorgente di Vertical Pod Autoscaler. 1. Clona il repository GitHub [kubernetes/autoscaler](https://github.com/kubernetes/autoscaler). ``` git clone https://github.com/kubernetes/autoscaler.git ``` 1. Passare alla directory `vertical-pod-autoscaler`. ``` cd autoscaler/vertical-pod-autoscaler/ ``` 1. (Facoltativo) Se è già stata implementata un'altra versione di Vertical Pod Autoscaler, rimuoverla con il comando seguente. ``` ./hack/vpa-down.sh ``` 1. Se i nodi non hanno accesso Internet al registro del container `registry.k8s.io`, devi estrarre le seguenti immagini e inviarle al tuo repository privato. Per ulteriori informazioni su come estrarre e inviare immagini al tuo repository privato, consulta la sezione [Copia di un'immagine di container da un repository a un altro](copy-image-to-repository.md). ``` registry.k8s.io/autoscaling/vpa-admission-controller:0.10.0 registry.k8s.io/autoscaling/vpa-recommender:0.10.0 registry.k8s.io/autoscaling/vpa-updater:0.10.0 ``` Se invii le immagini a un repository Amazon ECR privato, sostituisci `registry.k8s.io` nei manifesti con il tuo registro. Sostituire 111122223333 con l'ID account. Sostituisci region-code con la regione AWS in cui si trova il cluster. I comandi seguenti presuppongono che tu abbia dato al repository lo stesso nome del repository nel manifesto. Se hai dato un nome diverso al repository, dovrai modificare anch’esso. ``` sed -i.bak -e 's/registry.k8s.io/111122223333.dkr.ecr.region-code.amazonaws.com/' ./deploy/admission-controller-deployment.yaml sed -i.bak -e 's/registry.k8s.io/111122223333.dkr.ecr.region-code.amazonaws.com/' ./deploy/recommender-deployment.yaml sed -i.bak -e 's/registry.k8s.io/111122223333.dkr.ecr.region-code.amazonaws.com/' ./deploy/updater-deployment.yaml ``` 1. Implementare Vertical Pod Autoscaler nel cluster mediante il comando seguente. ``` ./hack/vpa-up.sh ``` 1. Verifica che i pod di Vertical Pod Autoscaler siano stati creati correttamente. ``` kubectl get pods -n kube-system ``` Di seguito viene riportato un output di esempio: ``` NAME READY STATUS RESTARTS AGE [...] metrics-server-8459fc497-kfj8w 1/1 Running 0 83m vpa-admission-controller-68c748777d-ppspd 1/1 Running 0 7s vpa-recommender-6fc8c67d85-gljpl 1/1 Running 0 8s vpa-updater-786b96955c-bgp9d 1/1 Running 0 8s ``` ## Test dell'installazione di Vertical Pod Autoscaler In questa sezione, verrà implementata un'applicazione di esempio per verificare il corretto funzionamento di Vertical Pod Autoscaler. 1. Implementare l'applicazione di esempio `hamster.yaml` per Vertical Pod Autoscaler mediante il comando seguente. ``` kubectl apply -f examples/hamster.yaml ``` 1. Recupera i pod dall’applicazione esemplificativa `hamster`. ``` kubectl get pods -l app=hamster ``` Di seguito viene riportato un output di esempio: ``` hamster-c7d89d6db-rglf5 1/1 Running 0 48s hamster-c7d89d6db-znvz5 1/1 Running 0 48s ``` 1. Descrivi uno dei pod per visualizzare la prenotazione di `cpu` e `memory`. Sostituisci c7d89d6db-rglf5 con uno degli ID restituiti nell'output del passaggio precedente. ``` kubectl describe pod hamster-c7d89d6db-rglf5 ``` Di seguito viene riportato un output di esempio: ``` [...] Containers: hamster: Container ID: docker://e76c2413fc720ac395c33b64588c82094fc8e5d590e373d5f818f3978f577e24 Image: registry.k8s.io/ubuntu-slim:0.1 Image ID: docker-pullable://registry.k8s.io/ubuntu-slim@sha256:b6f8c3885f5880a4f1a7cf717c07242eb4858fdd5a84b5ffe35b1cf680ea17b1 Port: Host Port: Command: /bin/sh Args: -c while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done State: Running Started: Fri, 27 Sep 2019 10:35:16 -0700 Ready: True Restart Count: 0 Requests: cpu: 100m memory: 50Mi [...] ``` Nota che il pod originale riserva 100 millicpu di CPU e 50 mebibyte di memoria. Per questa applicazione esemplificativa, 100 millicpu è un valore inferiore a quanto il pod deve eseguire, quindi risulta limitato dalla CPU. Il pod riserva inoltre una quantità di memoria nettamente inferiore rispetto alla necessaria. L’implementazione di Vertical Pod Autoscaler `vpa-recommender` analizza i pod hamster per verificare se i requisiti di CPU e memoria siano appropriati. Se sono necessari adeguamenti, `vpa-updater` rilancia i pod con valori aggiornati. 1. Attendi che `vpa-updater` avvii un nuovo pod hamster. Potrebbero essere necessari uno o due minuti. È possibile monitorare i pod con il comando seguente. Nota Se non si è sicuri che sia stato avviato un nuovo pod, confronta i nomi dei pod facendo riferimento all’elenco precedente. All’avvio del nuovo pod, sarà visualizzato il relativo nome. ``` kubectl get --watch Pods -l app=hamster ``` 1. Quando è avviato un nuovo pod hamster, aggiungi una descrizione e visualizza le prenotazioni di CPU e memoria aggiornate. ``` kubectl describe pod hamster-c7d89d6db-jxgfv ``` Di seguito viene riportato un output di esempio: ``` [...] Containers: hamster: Container ID: docker://2c3e7b6fb7ce0d8c86444334df654af6fb3fc88aad4c5d710eac3b1e7c58f7db Image: registry.k8s.io/ubuntu-slim:0.1 Image ID: docker-pullable://registry.k8s.io/ubuntu-slim@sha256:b6f8c3885f5880a4f1a7cf717c07242eb4858fdd5a84b5ffe35b1cf680ea17b1 Port: Host Port: Command: /bin/sh Args: -c while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done State: Running Started: Fri, 27 Sep 2019 10:37:08 -0700 Ready: True Restart Count: 0 Requests: cpu: 587m memory: 262144k [...] ``` Nell'output precedente puoi osservare che la prenotazione della `cpu` è passata a 587 millicpu, ossia un valore di oltre cinque volte superiore a quello originale. La `memory` è aumentata a 262.144 KB (circa 250 mebibyte), ossia cinque volte il valore originale. Questo pod disponeva di un numero insufficiente di risorse e pertanto Vertical Pod Autoscaler ha corretto la stima con un valore più adeguato. 1. Descrivere la risorsa `hamster-vpa` per visualizzare la nuova raccomandazione. ``` kubectl describe vpa/hamster-vpa ``` Di seguito viene riportato un output di esempio: ``` Name: hamster-vpa Namespace: default Labels: Annotations: kubectl.kubernetes.io/last-applied-configuration: {"apiVersion":"autoscaling.k8s.io/v1beta2","kind":"VerticalPodAutoscaler","metadata":{"annotations":{},"name":"hamster-vpa","namespace":"d... API Version: autoscaling.k8s.io/v1beta2 Kind: VerticalPodAutoscaler Metadata: Creation Timestamp: 2019-09-27T18:22:51Z Generation: 23 Resource Version: 14411 Self Link: /apis/autoscaling.k8s.io/v1beta2/namespaces/default/verticalpodautoscalers/hamster-vpa UID: d0d85fb9-e153-11e9-ae53-0205785d75b0 Spec: Target Ref: API Version: apps/v1 Kind: Deployment Name: hamster Status: Conditions: Last Transition Time: 2019-09-27T18:23:28Z Status: True Type: RecommendationProvided Recommendation: Container Recommendations: Container Name: hamster Lower Bound: Cpu: 550m Memory: 262144k Target: Cpu: 587m Memory: 262144k Uncapped Target: Cpu: 587m Memory: 262144k Upper Bound: Cpu: 21147m Memory: 387863636 Events: ``` 1. Dopo aver provato l'applicazione di esempio, è possibile eliminarla con il comando seguente. ``` kubectl delete -f examples/hamster.yaml ``` # Scalare le implementazioni dei pod con Horizontal Pod Autoscaler [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) di Kubernetes scala automaticamente il numero di pod in un’implementazione, un controller di replica o un set di repliche in base all’utilizzo della CPU di tale risorsa. Ciò consente alle applicazioni di aumentare orizzontalmente le risorse in base all’aumento della domanda, o di ridurle orizzontalmente quando non sono necessarie, liberando così i nodi per altre applicazioni. Quando imposti una percentuale di utilizzo della CPU target, Horizontal Pod Autoscaler aumenta o riduce le risorse dell’applicazione in modo conforme all’obiettivo prefissato. Horizontal Pod Autoscaler è una risorsa API standard in Kubernetes il cui funzionamento richiede solo l’installazione di una fonte di parametri, (ad esempio Kubernetes Metrics Server), nel cluster Amazon EKS. Non è necessario implementare o installare Horizontal Pod Autoscaler sul cluster per iniziare a dimensionare le applicazioni. Per ulteriori informazioni, consulta [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) nella documentazione Kubernetes. Utilizza questo argomento per preparare Horizontal Pod Autoscaler per il cluster Amazon EKS e per verificare che funzioni con un’applicazione di esempio. Nota Questo argomento si basa su [Horizontal Pod autoscaler walkthrough](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/) nella documentazione Kubernetes. + Il cluster Amazon EKS è già esistente. Se non lo è, consulta [Nozioni di base su Amazon EKS](getting-started.md). + Kubernetes Metrics Server è già installato. Per ulteriori informazioni, consulta [Visualizza l’utilizzo delle risorse con Kubernetes Metrics Server](metrics-server.md). + Stai utilizzando un client `kubectl` che è [configurato per comunicare con il cluster Amazon EKS](getting-started-console.md#eks-configure-kubectl). ## Esecuzione di un’applicazione di test di Horizontal Pod Autoscaler In questa sezione implementerai un’applicazione di esempio per verificare il corretto funzionamento di Horizontal Pod Autoscaler. Nota Questo esempio si basa su [Horizontal Pod autoscaler walkthrough](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/) nella documentazione Kubernetes. 1. Implementa un’applicazione server Web Apache con il comando seguente. ``` kubectl apply -f https://k8s.io/examples/application/php-apache.yaml ``` Questo pod di server Web Apache ha un limite di CPU di 500 millicpu e serve sulla porta 80. 1. Crea una risorsa Horizontal Pod Autoscaler per l’implementazione di `php-apache`. ``` kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10 ``` Questo comando crea un componente di scalabilità automatica che punta a un utilizzo della CPU del 50% per l’implementazione, con un minimo di un pod e un massimo di dieci pod. Quando il carico medio della CPU è inferiore al 50%, tale componente cerca di ridurre il numero di pod nell’implementazione, fino a un minimo di uno. Quando il carico è maggiore del 50%, il componente di scalabilità automatica cerca di aumentare il numero di pod nell’implementazione, fino a un massimo di dieci. Per ulteriori informazioni, consulta [How does a HorizontalPodAutoscaler work?](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#how-does-a-horizontalpodautoscaler-work) nella documentazione Kubernetes. 1. Descrivere il componente di scalabilità automatica con il comando seguente per visualizzarne i dettagli. ``` kubectl get hpa ``` Di seguito viene riportato un output di esempio: ``` NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE php-apache Deployment/php-apache 0%/50% 1 10 1 51s ``` Come si può vedere, il carico attuale della CPU è `0%` perché non è ancora presente il carico sul server. Il conteggio dei pod è già al limite più basso (uno), quindi non può essere ridotto. 1. Crea un carico per il server Web eseguendo un container. ``` kubectl run -i \ --tty load-generator \ --rm --image=busybox \ --restart=Never \ -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done" ``` 1. Per osservare l’incremento dell’implementazione, esegui periodicamente il seguente comando in un terminale separato dal terminale in cui hai eseguito il passaggio precedente. ``` kubectl get hpa php-apache ``` Di seguito viene riportato un output di esempio: ``` NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE php-apache Deployment/php-apache 250%/50% 1 10 5 4m44s ``` Potrebbe essere necessario più di un minuto per aumentare il numero di repliche. Finché la percentuale effettiva della CPU è superiore alla percentuale di destinazione, il conteggio delle repliche aumenta fino a 10. In questo caso, è `250%`, quindi il numero di `REPLICAS` continua ad aumentare. Nota Potrebbero essere necessari alcuni minuti prima che il numero di repliche raggiunga il limite massimo. Se, ad esempio, sono necessarie solo 6 repliche affinché il carico della CPU rimanga pari o inferiore al 50%, il carico non verrà dimensionato oltre 6 repliche. 1. Arresta il carico. Nella finestra del terminale in cui si sta generando il carico, arrestare quest’ultimo tenendo premuti i tasti `Ctrl+C`. È possibile guardare il dimensionamento delle repliche nuovamente a 1 eseguendo di nuovo il seguente comando nel terminale corrispondente. ``` kubectl get hpa ``` Di seguito viene riportato un output di esempio: ``` NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE php-apache Deployment/php-apache 0%/50% 1 10 1 25m ``` Nota Il periodo di tempo di default per il ridimensionamento è di cinque minuti, quindi ci vorrà un po’ di tempo prima di vedere il conteggio delle repliche raggiungere di nuovo 1, anche quando la percentuale corrente della CPU è 0. L’intervallo di tempo è modificabile. Per ulteriori informazioni, consulta [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) nella documentazione Kubernetes. 1. Al termine dell’esercitazione con l’applicazione di esempio, elimina le risorse `php-apache`. ``` kubectl delete deployment.apps/php-apache service/php-apache horizontalpodautoscaler.autoscaling/php-apache ``` # Esecuzione del routing del traffico TCP e UDP con Network Load Balancer Nota Novità: la modalità automatica di Amazon EKS automatizza le attività di routine per il bilanciamento del carico. Per ulteriori informazioni, consulta: [Implementa un carico di lavoro del bilanciatore del carico esemplificativo in EKS Auto Mode](auto-elb-example.md) [Usa Annotazioni del servizio per configurare Network Load Balancer](auto-configure-nlb.md) Il traffico di rete è bilanciato al carico `L4` del modello OSI. Per bilanciare il carico del traffico delle applicazioni`L7`, distribuisci un Kubernetes`ingress`, che fornisce un Application Load AWS Balancer. Per ulteriori informazioni, consulta [Instradare il traffico di applicazioni e HTTP con Application Load Balancer](alb-ingress.md). Per ulteriori informazioni sulle differenze tra i due tipi di bilanciamento del carico, consulta le funzionalità di [Elastic Load Balancing](https://aws.amazon.com/elasticloadbalancing/features/) sul AWS sito Web. [Quando crei un Kubernetes `Service` di tipo Kubernetes`LoadBalancer`, il controller di bilanciamento del carico del provider AWS cloud crea AWS[Classic Load Balancer per impostazione predefinita, ma può anche creare Network Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/introduction.html). AWS](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/introduction.html) Questo controller in futuro riceverà solo correzioni di bug critici. Per ulteriori informazioni sull'utilizzo del load balancer del provider AWS cloud, consulta il controller di bilanciamento del carico del provider [AWS cloud](https://kubernetes.io/docs/concepts/services-networking/service/#loadbalancer) nella documentazione di Kubernetes. Il suo utilizzo non è descritto in questo argomento. Ti consigliamo di utilizzare una versione `2.7.2` o successiva del [AWS Load Balancer Controller anziché il controller](aws-load-balancer-controller.md) di bilanciamento del carico del provider AWS cloud. Il AWS Load Balancer Controller crea AWS Network Load Balancer, ma non crea AWS Classic Load Balancer. Il resto di questo argomento riguarda l'utilizzo del AWS Load Balancer Controller. Un AWS Network Load Balancer può bilanciare il carico del traffico di rete su Pods distribuiti su destinazioni IP e [istanze EC2 ](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html#target-type) Amazon, su destinazioni IP AWS Fargate o su nodi ibridi Amazon EKS come destinazioni IP. Per ulteriori informazioni, vedere [AWS Load Balancer Controller](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/targetgroupbinding/targetgroupbinding/#targettype) su. GitHub ## Prerequisiti Prima di poter bilanciare il carico del traffico di rete utilizzando il AWS Load Balancer Controller, è necessario soddisfare i seguenti requisiti. + Avere un cluster esistente. Se non si dispone di un cluster esistente, consultare [Nozioni di base su Amazon EKS](getting-started.md). Se è necessario aggiornare la versione di un cluster esistente, vedere [Aggiornamento del cluster esistente alla nuova versione di Kubernetes](update-cluster.md). + Implementa il AWS Load Balancer Controller sul tuo cluster. Per ulteriori informazioni, consulta [Indirizza il traffico Internet con AWS Load Balancer Controller](aws-load-balancer-controller.md). Consigliamo la versione `2.7.2` o successiva. + Disporre di almeno una sottorete. Se si trovano più sottoreti con tag in una zona di disponibilità, il controller sceglie la sottorete il cui ID sottorete viene prima in ordine lessicografico. La sottorete deve avere a disposizione almeno otto indirizzi IP. + Se utilizzi la versione AWS Load Balancer Controller `2.1.1` o precedente, le sottoreti devono essere etichettate come segue. Se si utilizza la versione `2.1.2` o successiva, questo tag è facoltativo. Potresti voler etichettare una sottorete se hai più cluster in esecuzione nello stesso VPC o più AWS servizi che condividono sottoreti in un VPC e desideri un maggiore controllo su dove vengono forniti i load balancer per ogni cluster. Se specifichi esplicitamente la sottorete IDs come annotazione su un oggetto servizio, Kubernetes e il Load AWS Balancer Controller utilizzano tali sottoreti direttamente per creare il load balancer. L’assegnazione di tag delle sottoreti non è obbligatoria se si sceglie di utilizzare questo metodo per il provisioning dei bilanciatori del carico ed è possibile ignorare i seguenti requisiti di assegnazione di tag delle sottoreti pubbliche e private. Sostituisci my-cluster con il nome del cluster. + Chiave: `kubernetes.io/cluster/` + Valore: `shared` o `owned` + Le sottoreti pubbliche e private devono soddisfare i seguenti requisiti, a meno che non specifichi esplicitamente subnet come annotazione su un servizio o un oggetto di ingresso. IDs Se esegui il provisioning dei load balancer specificando esplicitamente la sottorete IDs come annotazione su un servizio o un oggetto di ingresso, Kubernetes e il Load Balancer Controller utilizzano tali sottoreti direttamente per creare il AWS load balancer e i seguenti tag non sono necessari. + Sottoreti private: deve essere taggato nel seguente formato. In questo modo Kubernetes e Load Balancer Controller sanno che le sottoreti possono essere utilizzate per bilanciatori di AWS carico interni. Se utilizzi `eksctl` o un AWS AWS CloudFormation modello Amazon EKS per creare il tuo VPC dopo il 26 marzo 2020, le sottoreti vengono etichettate in modo appropriato al momento della creazione. Per ulteriori informazioni sui modelli AWS AWS CloudFormation VPC Amazon EKS, vedere [Creazione di un Amazon VPC per il cluster Amazon EKS.](creating-a-vpc.md). + Chiave: `kubernetes.io/role/internal-elb` + Valore: `1` + Sottoreti pubbliche: deve essere taggato nel seguente formato. In questo modo Kubernetes sa come utilizzare solo quelle sottoreti per bilanciatori di carico esterni invece di scegliere una sottorete pubblica in ogni zona di disponibilità (in base all'ordine lessicografico della sottorete). IDs Se utilizzi `eksctl` o un AWS CloudFormation modello Amazon EKS per creare il tuo VPC dopo il 26 marzo 2020, le sottoreti vengono etichettate in modo appropriato al momento della creazione. Per ulteriori informazioni sui modelli AWS CloudFormation VPC di Amazon EKS, consulta. [Creazione di un Amazon VPC per il cluster Amazon EKS.](creating-a-vpc.md) + Chiave: `kubernetes.io/role/elb` + Valore: `1` Se i tag del ruolo della sottorete non vengono aggiunti in modo esplicito, il controller del servizio Kubernetes esamina la tabella di routing delle sottoreti VPC del cluster per determinare se la sottorete è privata o pubblica. Si consiglia di non fare affidamento su questo comportamento e di aggiungere esplicitamente i tag di ruolo pubblici o privati. Il AWS Load Balancer Controller non esamina le tabelle delle rotte e richiede la presenza dei tag privati e pubblici per una corretta individuazione automatica. ## Considerazioni + La configurazione del load balancer è controllata da annotazioni che vengono aggiunte al manifest del servizio. Le annotazioni del servizio sono diverse quando si utilizza il AWS Load Balancer Controller rispetto a quando si utilizza AWS il controller di bilanciamento del carico del provider cloud. Assicurati di controllare [le annotazioni](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/annotations/) per il AWS Load Balancer Controller prima di distribuire i servizi. + Quando si utilizza il [plug-in Amazon VPC CNI per Kubernetes,](managing-vpc-cni.md) il Load AWS Balancer Controller può bilanciare il carico su destinazioni IP o istanze EC2 Amazon e destinazioni IP Fargate. Quando utilizzi [plug-in CNI compatibili alternativi](alternate-cni-plugins.md), il controller può bilanciare il carico solo per le destinazioni di istanza, a meno che non si stia bilanciando il carico su Amazon EKS Hybrid Nodes. Per i nodi ibridi, il controller può bilanciare il carico delle destinazioni IP. Per ulteriori informazioni sui tipi di destinazioni dei Network Load Balancer, consultare [Target type](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html#target-type) (Tipo di destinazione) nella Guida per l'utente di Network Load Balancer. + Se si desidera aggiungere tag al bilanciatore del carico quando o dopo la sua creazione, aggiungere la seguente annotazione nella specifica del servizio. Per ulteriori informazioni, consulta [AWS Resource Tags](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/annotations/#aws-resource-tags) nella documentazione del AWS Load Balancer Controller. ``` service.beta.kubernetes.io/aws-load-balancer-additional-resource-tags ``` + È possibile assegnare [Indirizzi IP elastici](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) al Network Load Balancer aggiungendo la seguente annotazione. Sostituisci i valori `Allocation IDs` di esempio con i tuoi indirizzi IP elastici. Il numero di `Allocation IDs` deve corrispondere al numero di sottoreti utilizzate per il load balancer. Per ulteriori informazioni, consultare la documentazione sul [Controller del load balancer AWS](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/annotations/#eip-allocations). ``` service.beta.kubernetes.io/aws-load-balancer-eip-allocations: eipalloc-xxxxxxxxxxxxxxxxx,eipalloc-yyyyyyyyyyyyyyyyy ``` + Amazon EKS aggiunge una regola in entrata al gruppo di sicurezza del nodo per il traffico client e una regola per ogni sottorete del bilanciatore del carico nel VPC per i controlli dell’integrità per ogni Network Load Balancer creato. L'implementazione di un servizio di tipo `LoadBalancer` può non riuscire se Amazon EKS tenta di creare regole che superano la quota per il numero massimo di regole consentite per un gruppo di sicurezza. Per ulteriori informazioni, consultare [Gruppi di sicurezza](https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html#vpc-limits-security-groups) in Quote di Amazon VPC nella Guida per l'utente di Amazon VPC. Considerare le opzioni seguenti per ridurre al minimo le possibilità di superare il numero massimo di regole per un gruppo di sicurezza: + Richiedere un aumento delle regole per ogni quota di gruppo di sicurezza. Per ulteriori informazioni, consultare [Richiesta di un aumento di quota](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html) nella Guida per l'utente di Service Quotas. + Al posto di destinazioni di istanza, utilizzare destinazioni IP. Con le destinazioni IP, è possibile condividere le regole per le stesse porte di destinazione. È possibile specificare manualmente le sottoreti del load balancer con un'annotazione. Per ulteriori informazioni, consulta [Annotations](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/annotations/) on GitHub. + Utilizzare un ingresso invece di un servizio di tipo `LoadBalancer` per inviare traffico al tuo servizio. L' AWS Application Load Balancer richiede meno regole rispetto ai Network Load Balancer. È possibile condividere un ALB su più ingressi. Per ulteriori informazioni, consulta [Instradare il traffico di applicazioni e HTTP con Application Load Balancer](alb-ingress.md). Non è possibile condividere un Network Load Balancer su più servizi. + Implementa i cluster su più account. + Se i pod vengono eseguiti su Windows in un cluster Amazon EKS, un singolo servizio con un bilanciatore del carico può supportare fino a 1024 pod back-end. Ogni pod ha il proprio indirizzo IP univoco. + Consigliamo di creare nuovi Network Load Balancer solo con il Load AWS Balancer Controller. Il tentativo di sostituire i Network Load Balancer esistenti creati con il controller di bilanciamento del carico del provider di servizi AWS cloud può comportare la creazione di più Network Load Balancer che potrebbero causare tempi di inattività delle applicazioni. ## Creazione di un Network Load Balancer È possibile creare un Network Load Balancer con destinazioni IP o istanza. ### Creare un Network Load Balancer: destinazioni IP + Puoi utilizzare destinazioni IP con pod distribuiti su EC2 nodi Amazon, Fargate o nodi ibridi Amazon EKS. Il servizio Kubernetes deve essere creato come tipo `LoadBalancer`. Per ulteriori informazioni, consulta [Type LoadBalancer](https://kubernetes.io/docs/concepts/services-networking/service/#loadbalancer) nella documentazione di Kubernetes. Per creare un load balancer che utilizzi destinazioni IP, aggiungere le seguenti annotazioni a un manifesto del servizio e implementare il servizio. Il `external` valore per `aws-load-balancer-type` è ciò che fa sì che il AWS Load Balancer Controller, anziché il controller del load balancer del provider AWS cloud, crei il Network Load Balancer. É possibile visualizzare un [manifesto del servizio di esempio](#network-load-balancing-service-sample-manifest) con le annotazioni. ``` service.beta.kubernetes.io/aws-load-balancer-type: "external" service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: "ip" ``` Nota Se si sta eseguendo il bilanciamento del carico sui pod `IPv6`, aggiungere la seguente annotazione. È possibile bilanciare il carico solo su destinazioni da `IPv6` a IP, non su destinazioni di istanza. Senza questa annotazione, il bilanciamento del carico è su `IPv4`. ``` service.beta.kubernetes.io/aws-load-balancer-ip-address-type: dualstack ``` Per impostazione predefinita, i Network Load Balancer vengono creati con `internal` `aws-load-balancer-scheme`. È possibile avviare i Network Load Balancer in qualsiasi sottorete del VPC del cluster, incluse le sottoreti non specificate al momento della creazione del cluster. Kubernetes esamina la tabella di routing delle sottoreti per stabilire se sono pubbliche o private. Le sottoreti pubbliche hanno una route direttamente a Internet tramite un gateway Internet; non vale altrettanto per le sottoreti private. Se desideri creare un Network Load Balancer in una sottorete pubblica per bilanciare il carico sui nodi Amazon EC2 (Fargate può essere solo privato), `internet-facing` specificalo con la seguente annotazione: ``` service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing" ``` Nota Al fine di garantire la compatibilità con le versioni precedenti, l'annotazione `service.beta.kubernetes.io/aws-load-balancer-type: "nlb-ip"` è ancora supportata. Consigliamo, tuttavia, di utilizzare le annotazioni precedenti per i load balancer anziché `service.beta.kubernetes.io/aws-load-balancer-type: "nlb-ip"`. Importante Non modificare le annotazioni dopo aver creato il servizio. Se è necessario modificarlo, eliminare l'oggetto di servizio e crearlo nuovamente con il valore desiderato per questa annotazione. ### Creare un Network Load Balancer: destinazioni di istanza + Il controller di bilanciamento del carico del provider AWS cloud crea Network Load Balancer solo con destinazioni di istanza. La versione `2.2.0` e le successive del AWS Load Balancer Controller creano anche Network Load Balancer con destinazioni di istanza. Ti consigliamo di utilizzarlo, anziché il controller di bilanciamento del carico del provider AWS cloud, per creare nuovi Network Load Balancer. Puoi utilizzare gli obiettivi delle istanze Network Load Balancer con i Pod distribuiti sui nodi EC2 Amazon, ma non su Fargate. Per bilanciare il carico del traffico di rete tra i pod implementati su Fargate, è necessario utilizzare destinazioni IP. Per implementare un Network Load Balancer in una sottorete privata, la specifica del servizio deve avere le seguenti annotazioni. É possibile visualizzare un [manifesto del servizio di esempio](#network-load-balancing-service-sample-manifest) con le annotazioni. Il `external` valore per `aws-load-balancer-type` è ciò che fa sì che il AWS Load Balancer Controller, anziché il controller del load balancer del provider AWS cloud, crei il Network Load Balancer. ``` service.beta.kubernetes.io/aws-load-balancer-type: "external" service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: "instance" ``` Per impostazione predefinita, i Network Load Balancer vengono creati con `internal` `aws-load-balancer-scheme`. Per i Network Load Balancer interni, il cluster Amazon EKS deve essere configurato per l'utilizzo di almeno una sottorete privata nel VPC. Kubernetes esamina la tabella di routing delle sottoreti per stabilire se sono pubbliche o private. Le sottoreti pubbliche hanno una route direttamente a Internet tramite un gateway Internet; non vale altrettanto per le sottoreti private. Se desideri creare un Network Load Balancer in una sottorete pubblica per bilanciare il carico EC2 sui nodi Amazon, specificalo `internet-facing` con la seguente annotazione: ``` service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing" ``` Importante Non modificare le annotazioni dopo aver creato il servizio. Se è necessario modificarlo, eliminare l'oggetto di servizio e crearlo nuovamente con il valore desiderato per questa annotazione. ## (Facoltativo) Implementare un'applicazione di esempio + Almeno una sottorete pubblica o privata nel VPC del cluster. + Implementa il AWS Load Balancer Controller sul tuo cluster. Per ulteriori informazioni, consulta [Indirizza il traffico Internet con AWS Load Balancer Controller](aws-load-balancer-controller.md). Consigliamo la versione `2.7.2` o successiva. 1. Se si sta eseguendo l’implementazione su Fargate, assicurarsi di avere una sottorete privata disponibile nel VPC e di creare un profilo Fargate. Se non si sta eseguendo l’implementazione su Fargate, salta questo passaggio. Puoi creare il profilo eseguendo il seguente comando o nella [Console di gestione AWS](fargate-profile.md#create-fargate-profile) utilizzando gli stessi valori per `name` e `namespace` che si trovano nel comando. Sostituire i valori di esempio con i propri valori. ``` eksctl create fargateprofile \ --cluster my-cluster \ --region region-code \ --name nlb-sample-app \ --namespace nlb-sample-app ``` 1. Implementa un'applicazione di esempio. 1. Crea un namespace per l'applicazione. ``` kubectl create namespace nlb-sample-app ``` 1. Salva nel computer i seguenti contenuti in un file denominato `sample-deployment.yaml`. ``` apiVersion: apps/v1 kind: Deployment metadata: name: nlb-sample-app namespace: nlb-sample-app spec: replicas: 3 selector: matchLabels: app: nginx template: metadata: labels: app: nginx spec: containers: - name: nginx image: public.ecr.aws/nginx/nginx:1.23 ports: - name: tcp containerPort: 80 ``` 1. Applica il file manifesto al cluster. ``` kubectl apply -f sample-deployment.yaml ``` 1. Crea un servizio con un Network Load Balancer connesso a Internet che bilanci il carico sulle destinazioni IP. 1. Salva sul computer i seguenti contenuti in un file denominato `sample-service.yaml`. Se si sta eseguendo l’implementazione sui nodi Fargate, rimuovere la riga `service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing`. ``` apiVersion: v1 kind: Service metadata: name: nlb-sample-service namespace: nlb-sample-app annotations: service.beta.kubernetes.io/aws-load-balancer-type: external service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: ip service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing spec: ports: - port: 80 targetPort: 80 protocol: TCP type: LoadBalancer selector: app: nginx ``` 1. Applica il file manifesto al cluster. ``` kubectl apply -f sample-service.yaml ``` 1. Verifica che il servizio sia stato distribuito. ``` kubectl get svc nlb-sample-service -n nlb-sample-app ``` Di seguito viene riportato un output di esempio. ``` NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE sample-service LoadBalancer 10.100.240.137 k8s-nlbsampl-nlbsampl-xxxxxxxxxx-xxxxxxxxxxxxxxxx.elb.region-code.amazonaws.com 80:32400/TCP 16h ``` Nota I valori di 10.100.240.137 e xxxxxxxxxx - xxxxxxxxxxxxxxxx saranno diversi dall'output di esempio (saranno univoci per il sistema di bilanciamento del carico) e us-west-2 potrebbero essere diversi per te, a seconda della AWS regione in cui si trova il cluster. 1. Apri [Amazon EC2 Console di gestione AWS](https://console.aws.amazon.com/ec2). Seleziona Target Groups (Gruppi di destinazioni) in Load Balancing (Bilanciamento del carico) nel pannello di navigazione a sinistra. Nella colonna Nome, seleziona il nome del gruppo di destinazione in cui il valore nella colonna bilanciatore del carico corrisponde al nome nella colonna `EXTERNAL-IP` dell’output nel passaggio precedente. Ad esempio, se l’output era uguale all’output indicato sopra sarà necessario selezionare il gruppo di destinazione denominato `k8s-default-samplese-xxxxxxxxxx `. Target type (Tipo di destinazione) è `IP` perché è stato specificato nel manifesto del servizio di esempio. 1. Selezionare il proprio Gruppo di destinazione e poi scegliere la scheda Destinazioni. In Destinazioni registrate, verranno visualizzati tre indirizzi IP delle tre repliche implementate in un passaggio precedente. Prima di continuare, attendere fino a quando lo stato di tutti gli obiettivi è Integro. Potrebbero passare diversi minuti prima che tutti gli obiettivi siano `healthy`. Gli obiettivi potrebbero essere in uno stato `unhealthy` prima di passare a uno stato `healthy`. 1. Invia il traffico al servizio sostituendo xxxxxxxxxx-xxxxxxxxxxxxxxxx e us-west-2 con i valori restituiti nell'output di un [operazione precedente](#nlb-sample-app-verify-deployment) per `EXTERNAL-IP`. Se hai eseguito l’implementazione a una sottorete privata, devi visualizzare la pagina da un dispositivo all’interno del VPC, ad esempio un host bastione. Per ulteriori informazioni, consulta [Bastion host Linux in AWS](https://aws.amazon.com/quickstart/architecture/linux-bastion/). ``` curl k8s-default-samplese-xxxxxxxxxx-xxxxxxxxxxxxxxxx.elb.region-code.amazonaws.com ``` Di seguito viene riportato un output di esempio. ``` Welcome to nginx! [...] ``` 1. Al termine dell’implementazione, del servizio e del namespace esemplificativi, rimuoverli. ``` kubectl delete namespace nlb-sample-app ``` # Instradare il traffico di applicazioni e HTTP con Application Load Balancer Nota Novità: la modalità automatica di Amazon EKS automatizza le attività di routine per il bilanciamento del carico. Per ulteriori informazioni, consulta: [Implementa un carico di lavoro del bilanciatore del carico esemplificativo in EKS Auto Mode](auto-elb-example.md) [Creare e IngressClass configurare un Application Load Balancer](auto-configure-alb.md) Quando crei un Kubernetes`ingress`, viene fornito un Application Load AWS Balancer (ALB) che bilancia il carico del traffico delle applicazioni. Per ulteriori informazioni, consulta [Cos'è un Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html)? nella Guida per l'utente di Application Load Balancers e [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) nella documentazione di Kubernetes. ALBs può essere utilizzato con i Pod distribuiti sui nodi o su AWS Fargate. È possibile implementare un ALB a sottoreti pubbliche o private. Il traffico delle applicazioni è bilanciato a `L7` del modello OSI. Per bilanciare il carico del traffico di rete a `L4`, implementare un `service` Kubernetes del tipo `LoadBalancer`. Questo tipo fornisce un AWS Network Load Balancer. Per ulteriori informazioni, consulta [Esecuzione del routing del traffico TCP e UDP con Network Load Balancer](network-load-balancing.md). Per ulteriori informazioni sulle differenze tra i due tipi di bilanciamento del carico, consulta le funzionalità di [Elastic Load Balancing](https://aws.amazon.com/elasticloadbalancing/features/) sul AWS sito Web. ## Prerequisiti Prima di poter bilanciare il carico del traffico dell’applicazione in un’applicazione, è necessario soddisfare i seguenti requisiti. + Avere un cluster esistente. Se non si dispone di un cluster esistente, consultare [Nozioni di base su Amazon EKS](getting-started.md). Se è necessario aggiornare la versione di un cluster esistente, vedere [Aggiornamento del cluster esistente alla nuova versione di Kubernetes](update-cluster.md). + Implementa il AWS Load Balancer Controller sul tuo cluster. Per ulteriori informazioni, consulta [Indirizza il traffico Internet con AWS Load Balancer Controller](aws-load-balancer-controller.md). Consigliamo la versione `2.7.2` o successiva. + Almeno due sottoreti devono trovarsi in diverse zone di disponibilità. Il AWS Load Balancer Controller sceglie una sottorete da ogni zona di disponibilità. Quando si trovano più sottoreti taggate in una zona di disponibilità, il controller sceglie la sottorete il cui ID sottorete viene prima in ordine lessicografico. Ogni sottorete deve avere a disposizione almeno otto indirizzi IP. Se utilizzi più gruppi di sicurezza collegati al nodo (worker), esattamente un gruppo di sicurezza deve essere taggato come segue. Sostituisci my-cluster con il nome del cluster. + Chiave: `kubernetes.io/cluster/` + Valore: `shared` o `owned` + Se utilizzi la versione AWS Load Balancer Controller `2.1.1` o precedente, le sottoreti devono essere etichettate nel formato seguente. Se utilizzi la versione `2.1.2` o successiva, l’assegnazione di tag è facoltativa. Tuttavia, si consiglia di taggare una sottorete nel caso si verifichi una delle seguenti situazioni. Hai più cluster in esecuzione nello stesso VPC o AWS più servizi che condividono sottoreti in un VPC. Oppure, si desidera un maggiore controllo sulla posizione in cui viene eseguito il provisioning dei bilanciatori di carico per ciascun cluster. Sostituisci my-cluster con il nome del cluster. + Chiave: `kubernetes.io/cluster/` + Valore – `shared` o `owned` + Le sottoreti pubbliche e private devono soddisfare i seguenti requisiti. Questo a meno che non si specifichi esplicitamente subnet IDs come annotazione su un servizio o un oggetto in ingresso. Si supponga di effettuare il provisioning dei sistemi di bilanciamento del carico specificando esplicitamente la sottorete IDs come annotazione su un servizio o un oggetto in ingresso. In questa situazione, Kubernetes e il controller del AWS bilanciamento del carico utilizzano direttamente tali sottoreti per creare il sistema di bilanciamento del carico e i seguenti tag non sono necessari. + Sottoreti private: deve essere taggato nel seguente formato. In questo modo Kubernetes e il controller del bilanciamento del carico sanno che le sottoreti possono essere utilizzate per bilanciatori di AWS carico interni. Se utilizzi `eksctl` o un AWS CloudFormation modello Amazon EKS per creare il tuo VPC dopo il 26 marzo 2020, le sottoreti vengono etichettate in modo appropriato al momento della creazione. Per ulteriori informazioni sui modelli AWS CloudFormation VPC di Amazon EKS, consulta. [Creazione di un Amazon VPC per il cluster Amazon EKS.](creating-a-vpc.md) + Chiave: `kubernetes.io/role/internal-elb` + Valore: `1` + Sottoreti pubbliche – Deve essere taggato nel seguente formato. In questo modo Kubernetes sa di utilizzare solo le sottoreti specificate per i load balancer esterni. In questo modo, Kubernetes non sceglie una sottorete pubblica in ogni zona di disponibilità (in base all’ordine lessicografico degli ID sottorete). Se utilizzi `eksctl` o un AWS CloudFormation modello Amazon EKS per creare il tuo VPC dopo il 26 marzo 2020, le sottoreti vengono etichettate in modo appropriato al momento della creazione. Per ulteriori informazioni sui modelli AWS CloudFormation VPC di Amazon EKS, consulta. [Creazione di un Amazon VPC per il cluster Amazon EKS.](creating-a-vpc.md) + Chiave: `kubernetes.io/role/elb` + Valore: `1` Se i tag del ruolo della sottorete non vengono aggiunti in modo esplicito, il controller del servizio Kubernetes esamina la tabella di routing delle sottoreti VPC del cluster. Ciò consente di determinare se la sottorete è privata o pubblica. Si consiglia di non fare affidamento su questo comportamento. È preferibile, invece, aggiungere esplicitamente i tag del ruolo privato o pubblico. Il AWS Load Balancer Controller non esamina le tabelle delle rotte. Richiede inoltre la presenza di tag privati e pubblici per un efficiente rilevamento automatico. + Il [AWS Load Balancer Controller](https://github.com/kubernetes-sigs/aws-load-balancer-controller) crea ALBs le AWS risorse di supporto necessarie ogni volta che una risorsa di ingresso Kubernetes viene creata sul cluster con l'annotazione. `kubernetes.io/ingress.class: alb` La risorsa di ingresso configura l’ALB per instradare il traffico HTTP o HTTPS verso pod differenti all’interno del cluster. Per assicurarti che i tuoi oggetti in ingresso utilizzino il AWS Load Balancer Controller, aggiungi la seguente annotazione alla specifica di ingresso di Kubernetes. Per ulteriori informazioni, consulta [Specifiche di ingresso](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/ingress/spec/) su GitHub. ``` annotations: kubernetes.io/ingress.class: alb ``` Nota Se bilanci il carico sui pod `IPv6`, aggiungi la seguente annotazione alla specifica di ingresso. È possibile bilanciare il carico solo su destinazioni da `IPv6` a IP, non su destinazioni di istanza. Senza questa annotazione, il bilanciamento del carico è su `IPv4`. ``` alb.ingress.kubernetes.io/ip-address-type: dualstack ``` + Il AWS Load Balancer Controller supporta le seguenti modalità di traffico: + Istanza: registra i nodi all’interno del cluster come destinazioni per l’ALB. Il traffico che raggiunge l’ALB viene indirizzato a `NodePort` per il servizio e quindi inoltrato ai pod. Questa è la modalità di traffico predefinita. È anche possibile specificarla esplicitamente con l’annotazione `alb.ingress.kubernetes.io/target-type: instance`. Nota Il servizio Kubernetes deve specificare il tipo `NodePort` o `LoadBalancer` per utilizzare questa modalità di traffico. + IP – Registra i pod come destinazioni per l’ALB. Il traffico che raggiunge l’ALB viene indirizzato direttamente ai pod per il servizio. È necessario specificare l’annotazione `alb.ingress.kubernetes.io/target-type: ip` per utilizzare questa modalità di traffico. Il tipo di destinazione IP è richiesto quando i pod di destinazione sono in esecuzione su Fargate o Amazon EKS Hybrid Nodes. + Per etichettare ALBs creato dal controller, aggiungi la seguente annotazione al controller:. `alb.ingress.kubernetes.io/tags` Per un elenco di tutte le annotazioni disponibili supportate dal Load AWS Balancer Controller, [consulta Ingress](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/ingress/annotations/) annotations on. GitHub + L’aggiornamento o il downgrade della versione del controller ALB può introdurre modifiche importanti alle funzionalità che si basano su di essa. Per ulteriori informazioni sulle modifiche che vengono introdotte in ogni versione, consulta le [note di rilascio del controller ALB](https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases) su GitHub. ## Riutilizzo con Ingress Groups ALBs Puoi condividere un Application Load Balancer su più risorse di servizio tramite `IngressGroups`. Per aggiungere un ingresso a un gruppo, aggiungere la seguente annotazione a una specifica di risorsa di ingresso Kubernetes. ``` alb.ingress.kubernetes.io/group.name: my-group ``` Il nome del gruppo deve: + Avere una lunghezza pari o inferiore a 63 caratteri. + Essere formato da lettere minuscole, numeri, `-`, e `.` + Iniziare e finire con una lettera o un numero. Il controller unisce automaticamente le regole di ingresso per tutti gli ingressi nello stesso gruppo di ingresso. Le supporta con un singolo ALB. La maggior parte delle annotazioni definite in un ingresso si applica solo ai percorsi definiti da tale ingresso. Per impostazione predefinita, le risorse in ingresso non appartengono ad alcun gruppo di ingresso. avvertimento Potenziale rischio per la sicurezza Specifica un gruppo di ingressi per un ingresso solo quando tutti gli utenti Kubernetes che dispongono dell’autorizzazione RBAC per creare o modificare le risorse di ingresso rientrano nello stesso limite di attendibilità. Se si aggiunge l’annotazione con un nome di gruppo, altri utenti Kubernetes potrebbero creare o modificare i propri ingressi così da appartenere allo stesso gruppo di ingressi. Ciò può causare comportamenti indesiderati, ad esempio la sovrascrittura delle regole esistenti con regole con priorità più alta. Puoi aggiungere un numero d’ordine della risorsa di ingresso. ``` alb.ingress.kubernetes.io/group.order: '10' ``` Il numero può variare tra 1 e 1.000. Viene considerato prima il numero più basso per tutti gli ingressi nello stesso gruppo di ingressi. Tutti gli ingressi senza questa annotazione vengono valutati con un valore pari a zero. La duplicazione delle regole con un numero più alto può causare la sovrascrittura delle regole con un numero più basso. Per impostazione predefinita, l’ordine delle regole tra ingressi all’interno dello stesso gruppo di ingressi viene determinato in base all’ordine lessicografico del namespace e del nome. Importante Assicurarsi che ogni ingresso nello stesso gruppo di ingressi disponga di un numero di priorità univoco. Non puoi avere numeri d’ordine duplicati tra gli ingressi. ## (Facoltativo) Implementare un’applicazione di esempio + Almeno una sottorete pubblica o privata nel VPC del cluster. + Implementa il AWS Load Balancer Controller sul tuo cluster. Per ulteriori informazioni, consulta [Indirizza il traffico Internet con AWS Load Balancer Controller](aws-load-balancer-controller.md). Consigliamo la versione `2.7.2` o successiva. Puoi eseguire l'applicazione di esempio su un cluster con EC2 nodi Amazon, Fargate Pods o entrambi. 1. Se non stai eseguendo l’implementazione su Fargate, salta questa fase. Se stai eseguendo l’implementazione su Fargate, crea un profilo Fargate. Puoi creare il profilo eseguendo il seguente comando o nella [Console di gestione AWS](fargate-profile.md#create-fargate-profile) utilizzando gli stessi valori per `name` e `namespace` che si trovano nel comando. Sostituire i valori di esempio con i propri valori. ``` eksctl create fargateprofile \ --cluster my-cluster \ --region region-code \ --name alb-sample-app \ --namespace game-2048 ``` 1. Implementa il gioco [2048](https://play2048.co/) come applicazione di esempio per verificare che il Load AWS Balancer Controller crei AWS un ALB come risultato dell'oggetto di ingresso. Completa i passaggi per il tipo di sottorete verso la quale stai eseguendo l’implementazione. 1. Se stai eseguendo l’implementazione su pod in un cluster creato con la famiglia `IPv6`, passa alla fase successiva. + Pubblica: ``` kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/examples/2048/2048_full.yaml ``` + Privata: 1. Eseguire il download del manifesto. ``` curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/examples/2048/2048_full.yaml ``` 1. Modificare il file e individuare la riga `alb.ingress.kubernetes.io/scheme: internet-facing`. 1. Modificare internet-facing in `internal` e salvare il file. 1. Applicare il file manifesto al cluster. ``` kubectl apply -f 2048_full.yaml ``` 1. [Se lo stai distribuendo su Pods in un cluster creato con la famiglia, completa i IPv6 seguenti passaggi.](cni-ipv6.md) 1. Eseguire il download del manifesto. ``` curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/examples/2048/2048_full.yaml ``` 1. Aprire il file in un editor e aggiungere la seguente riga alle annotazioni nella specifica di ingresso. ``` alb.ingress.kubernetes.io/ip-address-type: dualstack ``` 1. Se stai bilanciando il carico sui pod interni piuttosto che sui pod rivolti a Internet, modifica la riga che indica `alb.ingress.kubernetes.io/scheme: internet-facing ` in `alb.ingress.kubernetes.io/scheme: internal` 1. Salvare il file. 1. Applica il file manifesto al cluster. ``` kubectl apply -f 2048_full.yaml ``` 1. Dopo pochi minuti, verificare che la risorsa di ingresso sia stata creata con il comando seguente. ``` kubectl get ingress/ingress-2048 -n game-2048 ``` Di seguito viene riportato un output di esempio: ``` NAME CLASS HOSTS ADDRESS PORTS AGE ingress-2048 * k8s-game2048-ingress2-xxxxxxxxxx-yyyyyyyyyy.region-code.elb.amazonaws.com 80 2m32s ``` Nota Se hai creato il load balancer in una sottorete privata, il valore in `ADDRESS` nell’output precedente è preceduto da `internal-`. Se l'ingresso non è stato creato correttamente dopo alcuni minuti, esegui il comando seguente per visualizzare i log del AWS Load Balancer Controller. Questi registri possono contenere messaggi di errore che consentono di diagnosticare eventuali problemi relativi all’implementazione. ``` kubectl logs -f -n kube-system -l app.kubernetes.io/instance=aws-load-balancer-controller ``` 1. Se è stata eseguita l’implementazione a una sottorete pubblica, aprire un browser e accedere all’URL `ADDRESS` dall’output del comando precedente per visualizzare l’applicazione di esempio. Se non visualizzi nulla, aggiorna il browser e riprova. Se hai eseguito l’implementazione a una sottorete privata, devi visualizzare la pagina da un dispositivo all’interno del VPC, ad esempio un host bastione. Per ulteriori informazioni, consulta [Bastion host Linux in AWS](https://aws.amazon.com/quickstart/architecture/linux-bastion/). ![\[Applicazioni di esempio 2048\]](http://docs.aws.amazon.com/it_it/eks/latest/userguide/images/2048.png) 1. Dopo aver provato l’applicazione di esempio, eliminarla utilizzando uno dei comandi seguenti. + Se è stato applicato il manifesto anziché una copia scaricata, utilizzare il comando seguente. ``` kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/examples/2048/2048_full.yaml ``` + Se è stato il manifesto scaricato e modificato, utilizzare il seguente comando. ``` kubectl delete -f 2048_full.yaml ``` # Limitazione degli indirizzi IP esterni assegnabili ai servizi I servizi Kubernetes possono essere raggiunti dall'interno di un cluster tramite: + Un indirizzo IP del cluster assegnato automaticamente da Kubernetes + Qualsiasi indirizzo IP specificato per la proprietà `externalIPs` in una specifica di servizio. Gli indirizzi IP esterni non sono gestiti da Kubernetes e sono responsabilità dell'amministratore del cluster. Gli Indirizzi IP esterni specificati con `externalIPs` sono diversi dall'indirizzo IP esterno assegnato a un servizio di tipo `LoadBalancer` da un provider cloud. Per ulteriori informazioni sui servizi Kubernetes, consultare [Servizio](https://kubernetes.io/docs/concepts/services-networking/service/) nella documentazione Kubernetes. È possibile limitare gli indirizzi IP che possono essere specificati per `externalIPs` in una specifica di servizio. 1. Implementazione di `cert-manager` per gestire i certificati webhook. Per ulteriori informazioni, consultare la documentazione [Cert-Manager](https://cert-manager.io/docs/). ``` kubectl apply -f https://github.com/jetstack/cert-manager/releases/download/v1.5.4/cert-manager.yaml ``` 1. Verifica che i pod `cert-manager` siano in esecuzione. ``` kubectl get pods -n cert-manager ``` Di seguito viene riportato un output di esempio: ``` NAME READY STATUS RESTARTS AGE cert-manager-58c8844bb8-nlx7q 1/1 Running 0 15s cert-manager-cainjector-745768f6ff-696h5 1/1 Running 0 15s cert-manager-webhook-67cc76975b-4v4nk 1/1 Running 0 14s ``` 1. Esamina i servizi esistenti per assicurarsi che a nessuno di essi siano assegnati indirizzi IP esterni non contenuti nell’intervallo CIDR per cui si desidera limitare gli indirizzi. ``` kubectl get services -A ``` Di seguito viene riportato un output di esempio: ``` NAMESPACE NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE cert-manager cert-manager ClusterIP 10.100.102.137 9402/TCP 20m cert-manager cert-manager-webhook ClusterIP 10.100.6.136 443/TCP 20m default kubernetes ClusterIP 10.100.0.1 443/TCP 2d1h externalip-validation-system externalip-validation-webhook-service ClusterIP 10.100.234.179 443/TCP 16s kube-system kube-dns ClusterIP 10.100.0.10 53/UDP,53/TCP 2d1h my-namespace my-service ClusterIP 10.100.128.10 192.168.1.1 80/TCP 149m ``` Se uno qualsiasi dei valori costituiscono indirizzi IP che non si trovano all’interno del blocco per cui si desidera limitare l’accesso, sarà necessario modificare gli indirizzi in modo che si trovino all’interno del blocco e implementare nuovamente i servizi. Ad esempio, al servizio `my-service` nell’output precedente è assegnato un indirizzo IP esterno che non rientra nell’intervallo CIDR esemplificativo del passaggio 5. 1. Eseguire il download del manifesto del webhook IP esterno. È anche possibile visualizzare il [codice sorgente per il webhook](https://github.com/kubernetes-sigs/externalip-webhook) su GitHub. ``` curl -O https://s3.us-west-2.amazonaws.com/amazon-eks/docs/externalip-webhook.yaml ``` 1. Specifica i blocchi CIDR. Aprire il file scaricato nell'editor e rimuovere il `\#` all'inizio delle righe seguenti. ``` #args: #- --allowed-external-ip-cidrs=10.0.0.0/8 ``` Sostituire `10.0.0.0/8` con il proprio blocco CIDR. É possibile specificare tutti i blocchi che si desiderano. Se si specificano blocchi multipli, aggiungere una virgola tra i blocchi. 1. Se il cluster non è nella regione AWS `us-west-2`, sostituisci `us-west-2`, `602401143452` e `amazonaws.com` nel file con i seguenti comandi. Prima di eseguire i comandi, sostituisci codice regione e 111122223333 con il valore per la tua regione AWS dall’elenco in [Visualizza i registri delle immagini dei container Amazon per i componenti aggiuntivi Amazon EKS](add-ons-images.md). ``` sed -i.bak -e 's|602401143452|111122223333|' externalip-webhook.yaml sed -i.bak -e 's|us-west-2|region-code|' externalip-webhook.yaml sed -i.bak -e 's|amazonaws.com||' externalip-webhook.yaml ``` 1. Applica il manifesto al cluster. ``` kubectl apply -f externalip-webhook.yaml ``` Qualsiasi tentativo di implementare un servizio nel cluster con un indirizzo IP specificato per `externalIPs` che non è contenuto nei blocchi specificati nella fase Specifica i blocchi CIDR avrà esito negativo. # Copia di un'immagine di container da un repository a un altro In questo argomento viene descritto come estrarre un’immagine di container da un repository a cui i nodi non hanno accesso e inviarla a un repository a cui i nodi hanno accesso. Puoi inviare l'immagine ad Amazon ECR o a un repository alternativo al quale i tuoi nodi hanno accesso. + Il motore Docker deve essere installato e configurato sul computer. Per ulteriori informazioni, consulta la sezione [Installazione del motore Docker](https://docs.docker.com/engine/install/) nella documentazione di Docker. + Versione `2.12.3` o successiva o versione `1.27.160` o successiva dell'interfaccia a riga di AWS comando (AWS CLI) installata e configurata sul dispositivo o. AWS CloudShell Per verificare la versione attuale, usa `aws --version | cut -d / -f2 | cut -d ' ' -f1`. I gestori di pacchetti come `yum` Homebrew per macOS sono spesso diverse versioni dell'ultima versione della CLI AWS . `apt-get` Per installare la versione più recente, consulta [Installazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [configurazione rapida con aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) nella Guida per l'utente dell'interfaccia a riga di AWS comando. La versione AWS CLI installata in AWS CloudShell potrebbe anche contenere diverse versioni precedenti alla versione più recente. Per aggiornarlo, consulta [Installazione della AWS CLI nella tua home directory nella Guida per](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) l'* AWS CloudShell utente. + Un endpoint VPC di interfaccia per Amazon ECR se si desidera che i nodi estraggano o trasferiscano le immagini di container in un repository Amazon ECR privato sulla rete di Amazon. Per ulteriori informazioni, consulta la sezione [Creazione degli endpoint VPC per Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/vpc-endpoints.html#ecr-setting-up-vpc-create) nella Guida per l'utente di Amazon Elastic Container Registry. Completa i passaggi seguenti per estrarre un'immagine del container da un repository e inviarla al tuo repository. Negli esempi riportati in questo argomento, viene estratta l’immagine per l’[helper di parametri del plugin CNI di Amazon VPC per Kubernetes](https://github.com/aws/amazon-vpc-cni-k8s/blob/master/cmd/cni-metrics-helper/README.md). Quando segui questi passaggi, assicurati di sostituire i valori di esempio con i tuoi valori. 1. Se non si dispone ancora di un repository Amazon ECR o di un altro repository, crearne uno a cui i nodi abbiano accesso. Il seguente comando crea un repository privato Amazon ECR. Il nome di un repository privato Amazon ECR deve iniziare con una lettera. Può contenere soltanto lettere minuscole, numeri, trattini (-), trattini bassi (\$1) e barre (/). Per ulteriori informazioni, consulta la sezione [Creazione di un repository privato](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) nella Guida per l'utente di Amazon Elastic Container Registry. Puoi sostituire cni-metrics-helper* con un qualsiasi valore a tua scelta. Come best practice, crea un repository separato per ogni immagine. Lo consigliamo perché i tag immagine devono essere univoci all'interno di un repository. Sostituisci region-code con una [AWS regione supportata da Amazon ECR.](https://docs.aws.amazon.com/general/latest/gr/ecr.html) ``` aws ecr create-repository --region region-code --repository-name cni-metrics-helper ``` 1. Determina il registro, il repository e il tag (facoltativo) dell'immagine che i nodi devono estrarre. Questa informazione è nel formato `registry/repository[:tag]`. Molti degli argomenti di Amazon EKS sull'installazione delle immagini richiedono l'applicazione di un file manifesto o l'installazione dell'immagine utilizzando un grafico Helm. Tuttavia, prima di applicare un file manifesto o installare un grafico Helm, visualizzare il contenuto del manifesto o del file `values.yaml` del grafico. In questo modo, puoi determinare il registro, il repository e il tag da estrarre. Ad esempio, è possibile trovare la seguente riga nel [file manifesto](https://raw.githubusercontent.com/aws/amazon-vpc-cni-k8s/v1.12.6/config/master/cni-metrics-helper.yaml) dell’[helper di parametri del plugin CNI di Amazon VPC per Kubernetes](https://github.com/aws/amazon-vpc-cni-k8s/blob/master/cmd/cni-metrics-helper/README.md). Il registro è `602401143452.dkr.ecr.us-west-2.amazonaws.com`, che è un registro privato Amazon ECR. Il repository è `cni-metrics-helper`. ``` image: "602401143452.dkr.ecr.us-west-2.amazonaws.com/cni-metrics-helper:v1.12.6" ``` Potresti visualizzate le seguenti varianti per la posizione dell'immagine: + Solo `repository-name:tag`. In questo caso, `docker.io` di solito è il registro, ma non è specificato poiché di default Kubernetes gli antepone un nome di repository se non viene specificato alcun registro. + `repository-name/repository-namespace/repository:tag`. il namespace del repository è facoltativo, ma talvolta viene specificato dal proprietario del repository per la classificazione delle immagini. Ad esempio, tutte le [ EC2 immagini Amazon nella Amazon ECR Public Gallery](https://gallery.ecr.aws/aws-ec2/) utilizzano lo `aws-ec2` spazio dei nomi. Prima di installare un'immagine con Helm, visualizza il file `values.yaml` Helm per determinare la posizione dell'immagine. Ad esempio, il file [values.yaml](https://github.com/aws/amazon-vpc-cni-k8s/blob/master/charts/cni-metrics-helper/values.yaml#L5-L9) dell’[helper di parametri del plugin CNI di Amazon VPC per Kubernetes](https://github.com/aws/amazon-vpc-cni-k8s/blob/master/cmd/cni-metrics-helper/README.md) include le seguenti righe. ``` image: region: us-west-2 tag: v1.12.6 account: "602401143452" domain: "amazonaws.com" ``` 1. Estrai l'immagine del container specificata nel file manifesto. 1. Se si esegue l’estrazione da un registro pubblico, come la [Galleria pubblica di Amazon ECR](https://gallery.ecr.aws/), è possibile passare alla fase secondaria successiva poiché l’autenticazione non è richiesta. In questo esempio, esegui l'autenticazione a un registro privato di Amazon ECR contenente il repository per l'immagine dell'helper per i parametri CNI. Amazon EKS conserva l’immagine in ogni registro elencato nella pagina [View Amazon container image registries for Amazon EKS add-ons](add-ons-images.md). Puoi eseguire l'autenticazione a uno qualsiasi dei registri sostituendo 602401143452 e region-code con le informazioni di un registro differente. Esiste un registro separato per ciascuna [Regione AWS in cui è supportato Amazon EKS](https://docs.aws.amazon.com/general/latest/gr/eks.html#eks_region). ``` aws ecr get-login-password --region region-code | docker login --username AWS --password-stdin 602401143452.dkr.ecr.region-code.amazonaws.com ``` 1. Estrai l'immagine. In questo esempio, esegui l'estrazione dal registro a cui ti sei autenticato nel passaggio secondario precedente. Sostituisci 602401143452 e region-code con le informazioni che hai fornito nella fase secondaria precedente. ``` docker pull 602401143452.dkr.ecr.region-code.amazonaws.com/cni-metrics-helper:v1.12.6 ``` 1. Tagga l'immagine che hai estratto con il registro, il repository e il tag. L'esempio seguente presuppone che tu abbia estratto l'immagine dal file manifesto e la invierai al repository privato Amazon ECR creato nel primo passaggio. Sostituisci 111122223333 con l'ID del tuo account. Sostituisci region-code con la AWS regione in cui hai creato il tuo repository privato Amazon ECR. ``` docker tag cni-metrics-helper:v1.12.6 111122223333.dkr.ecr.region-code.amazonaws.com/cni-metrics-helper:v1.12.6 ``` 1. Esegui l'autenticazione al tuo registro. In questo esempio, esegui l'autenticazione al registro privato Amazon ECR creato nel primo passaggio. Per ulteriori informazioni, consulta la sezione [Autenticazione del registro](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) nella Guida per l'utente di Amazon Elastic Container Registry. ``` aws ecr get-login-password --region region-code | docker login --username AWS --password-stdin 111122223333.dkr.ecr.region-code.amazonaws.com ``` 1. Invia l'immagine al tuo repository. In questo esempio, invii l'immagine al registro privato Amazon ECR creato nel primo passaggio. Per ulteriori informazioni, consulta la sezione [Invio di un'immagine Docker](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) nella Guida per l'utente di Amazon Elastic Container Registry. ``` docker push 111122223333.dkr.ecr.region-code.amazonaws.com/cni-metrics-helper:v1.12.6 ``` 1. Aggiorna il file manifesto utilizzato per determinare l'immagine in un passaggio precedente con il `registry/repository:tag` per l'immagine che hai inviato. Se si esegue l’installazione con un grafico Helm, spesso è possibile specificare il `registry/repository:tag`. Quando installi il grafico, specifica il `registry/repository:tag` dell'immagine che hai inviato al repository. # Visualizza i registri delle immagini del container per i componenti aggiuntivi di Amazon EKS Quando implementi [AWS Componenti aggiuntivi Amazon EKS](workloads-add-ons-available-eks.md) nel tuo cluster, i nodi estraggono le immagini dei container necessarie dal registro specificato nel meccanismo di installazione del componente aggiuntivo, ad esempio un manifesto di installazione o un file `values.yaml` Helm. Le immagini vengono estratte da un repository privato Amazon ECR di Amazon EKS. Amazon EKS replica le immagini in un repository in ogni regione supportata AWS da Amazon EKS. I nodi possono estrarre l’immagine del container su Internet da uno dei seguenti registri. In alternativa, i tuoi nodi possono trasferire l'immagine sulla rete di Amazon se hai creato un [endpoint VPC di interfaccia per Amazon ECR ()AWS PrivateLink nel](https://docs.aws.amazon.com/AmazonECR/latest/userguide/vpc-endpoints.html) tuo VPC. I registri richiedono l'autenticazione con un account IAM. AWS I tuoi nodi si autenticano utilizzando il [ruolo IAM del nodo Amazon EKS](create-node-role.md), a cui sono associate le autorizzazioni nella policy IAM EC2 ContainerRegistryReadOnly gestita di [Amazon](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ContainerRegistryReadOnly.html). | AWS Regione | Registro | | --- | --- | | af-south-1 | 877085696533.dkr.ecr.af-south-1.amazonaws.com | | ap-east-1 | 800184023465.dkr.ecr.ap-east-1.amazonaws.com | | ap-east-2 | 533267051163.dkr.ecr.ap-east-1.amazonaws.com | | ap-southeast-3 | 296578399912.dkr.ecr.ap-southeast-3.amazonaws.com | | ap-south-2 | 900889452093.dkr.ecr.ap-south-2.amazonaws.com | | ap-southeast-4 | 491585149902.dkr.ecr.ap-southeast-4.amazonaws.com | | ap-southeast-5 | 151610086707.dkr. ecr.ap-southeast-5.amazonaws.com | | ap-southeast-6 | 333609536671.dkr. ecr.ap-southeast-6.amazonaws.com | | ap-south-1 | 602401143452.dkr.ecr.ap-south-1.amazonaws.com | | ap-northeast-3 | 602401143452.dkr.ecr.ap-northeast-3.amazonaws.com | | ap-northeast-2 | 602401143452.dkr.ecr.ap-northeast-2.amazonaws.com | | ap-southeast-1 | 602401143452.dkr.ecr.ap-southeast-1.amazonaws.com | | ap-southeast-2 | 602401143452.dkr.ecr.ap-southeast-2.amazonaws.com | | ap-southeast-7 | 121268973566.dkr.ecr.ap-southeast-7.amazonaws.com | | ap-northeast-1 | 602401143452.dkr.ecr.ap-northeast-1.amazonaws.com | | cn-north-1 | 918309763551---dkr---ecr---cn-north-1.amazonaws.com.rproxy.govskope.us.cn | | cn-northwest-1 | 961992271922---dkr---ecr---cn-northwest-1.amazonaws.com.rproxy.govskope.us.cn | | eu-central-1 | 602401143452.dkr.ecr.eu-central-1.amazonaws.com | | eu-west-1 | 602401143452.dkr.ecr.eu-west-1.amazonaws.com | | eu-west-2 | 602401143452.dkr.ecr.eu-west-2.amazonaws.com | | eu-south-1 | 590381155156.dkr.ecr.eu-south-1.amazonaws.com | | eu-west-3 | 602401143452.dkr.ecr.eu-west-3.amazonaws.com | | eu-south-2 | 455263428931.dkr.ecr.eu-south-2.amazonaws.com | | eu-north-1 | 602401143452.dkr.ecr.eu-north-1.amazonaws.com | | eu-central-2 | 900612956339.dkr.ecr.eu-central-2.amazonaws.com | | il-central-1 | 066635153087.dkr.ecr.il-central-1.amazonaws.com | | mx-central-1 | 730335286997.dkr.ecr.mx-central-1.amazonaws.com | | me-south-1 | 558608220178.dkr.ecr.me-south-1.amazonaws.com | | me-central-1 | 759879836304.dkr.ecr.me-central-1.amazonaws.com | | us-east-1 | 602401143452.dkr.ecr.us-east-1.amazonaws.com | | us-east-2 | 602401143452.dkr.ecr.us-east-2.amazonaws.com | | us-west-1 | 602401143452.dkr.ecr.us-west-1.amazonaws.com | | us-west-2 | 602401143452.dkr.ecr.us-west-2.amazonaws.com | | ca-central-1 | 602401143452.dkr.ecr.ca-central-1.amazonaws.com | | ca-west-1 | 761377655185.dkr.ecr.ca-west-1.amazonaws.com | | sa-east-1 | 602401143452.dkr.ecr.sa-east-1.amazonaws.com | | us-gov-east-1 | 151742754352.dkr.ecr. us-gov-east-1amazonaws.com | | us-gov-west-1 | 013241004608.dkr.ecr. us-gov-west-1amazonaws.com | | eusc-de-east-1 | 877088126301.dkr.ecr. eusc-de-east-1. amazonaws.eu | # Componenti aggiuntivi Amazon EKS Un componente aggiuntivo è un software che fornisce funzionalità operative di supporto alle applicazioni Kubernetes, ma non è specifico per l'applicazione. Ciò include software come agenti di osservabilità o driver Kubernetes che consentono al cluster di interagire con le risorse sottostanti AWS per il networking, l'elaborazione e lo storage. Il software aggiuntivo viene in genere creato e gestito dalla community Kubernetes, dai provider di servizi cloud o da fornitori di terze parti. AWS Per ogni cluster, Amazon EKS installa automaticamente componenti aggiuntivi autogestiti come il plugin CNI di Amazon VPC per Kubernetes, `kube-proxy`, e CoreDNS. Tenere presente che il componente aggiuntivo CNI VPC non è compatibile con Amazon EKS Hybrid Nodes e non viene implementato su nodi ibridi. È possibile modificare la configurazione predefinita dei componenti aggiuntivi e aggiornarli quando lo desideri. I componenti aggiuntivi di Amazon EKS forniscono l'installazione e la gestione di un set curato di componenti aggiuntivi per i cluster Amazon EKS. Tutti i componenti aggiuntivi di Amazon EKS includono le patch di sicurezza e le correzioni di bug più recenti e sono convalidati per AWS funzionare con Amazon EKS. I componenti aggiuntivi Amazon EKS permettono di garantire costantemente sicurezza e stabilità ai cluster Amazon EKS e di ridurre la quantità di lavoro necessaria per installare, configurare e aggiornare i componenti aggiuntivi. Se un componente aggiuntivo autogestito, ad esempio `kube-proxy` è già in esecuzione nel cluster ed è disponibile come componente aggiuntivo di Amazon EKS, è possibile installare il componente aggiuntivo `kube-proxy` Amazon EKS per iniziare a beneficiare delle funzionalità dei componenti aggiuntivi di Amazon EKS. Tramite l'API Amazon EKS. è possibile aggiornare specifici campi di configurazione gestiti da Amazon EKS per i componenti aggiuntivi Amazon EKS. É anche possibile modificare i campi di configurazione non gestiti da Amazon EKS direttamente all'interno del cluster Kubernetes una volta avviato il componente aggiuntivo. Ciò include, ove applicabile, la definizione di campi di configurazione specifici per un componente aggiuntivo. Una volta apportate, queste modifiche non vengono sovrascritte da Amazon EKS. Ciò è reso possibile utilizzando la caratteristica applicazione lato server Kubernetes. Per ulteriori informazioni, consulta [Determina i campi che puoi personalizzare per i componenti aggiuntivi Amazon EKS](kubernetes-field-management.md). È possibile utilizzare i componenti aggiuntivi di Amazon EKS con qualsiasi tipo di nodo Amazon EKS. Per ulteriori informazioni, consulta [Gestire le risorse di elaborazione utilizzando i nodi](eks-compute.md). Puoi aggiungere, aggiornare o eliminare componenti aggiuntivi Amazon EKS utilizzando l'API Amazon EKS Console di gestione AWS, la AWS CLI e. `eksctl` La creazione di componenti aggiuntivi di Amazon EKS è possibile anche utilizzando [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-eks-addon.html). ## Considerazioni Tenere in considerazione quanto segue quando si utilizzano i componenti aggiuntivi Amazon EKS: + Per configurare i componenti aggiuntivi per il cluster, il [principale IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal) deve disporre delle autorizzazioni IAM per l'utilizzo dei componenti aggiuntivi. Per ulteriori informazioni, consulta le operazioni con `Addon` nel loro nome in [Operazioni definite da Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html#amazonelastickubernetesservice-actions-as-permissions). + I componenti aggiuntivi di Amazon EKS vengono eseguiti sui nodi con provisioning o configurazione per il cluster. I tipi di nodi includono EC2 istanze Amazon, Fargate e nodi ibridi. + È possibile modificare i campi non gestiti da Amazon EKS per personalizzare l’installazione di un componente aggiuntivo Amazon EKS. Per ulteriori informazioni, consulta [Determina i campi che puoi personalizzare per i componenti aggiuntivi Amazon EKS](kubernetes-field-management.md). + Se crei un cluster con Console di gestione AWS, i componenti aggiuntivi Amazon EKS`kube-proxy`, Amazon VPC CNI per Kubernetes e CoredNS Amazon EKS vengono aggiunti automaticamente al cluster. Se utilizzi `eksctl` per creare il cluster con un file `config`, `eksctl` può anche creare il cluster con i componenti aggiuntivi di Amazon EKS. Se si crea il cluster utilizzando `eksctl` senza un file `config` o con qualsiasi altro strumento, `kube-proxy` autogestito, il plugin CNI di Amazon VPC per Kubernetes e i componenti aggiuntivi CoreDNS vengono installati in alternativa ai componenti aggiuntivi Amazon EKS. Puoi gestirli in autonomia o aggiungere manualmente i componenti aggiuntivi di Amazon EKS dopo la creazione del cluster. Indipendentemente dal metodo utilizzato per creare il cluster, il componente aggiuntivo CNI VPC non viene installato sui nodi ibridi. + `eks:addon-cluster-admin` `ClusterRoleBinding` associa `cluster-admin` `ClusterRole` all’identità Kubernetes `eks:addon-manager`. Il ruolo dispone delle autorizzazioni necessarie all’identità `eks:addon-manager` per creare namespace Kubernetes e per installare componenti aggiuntivi nei namespace. Se il `ClusterRoleBinding` `eks:addon-cluster-admin` viene rimosso, il cluster Amazon EKS continua a funzionare, ma Amazon EKS non è più in grado di gestire i componenti aggiuntivi. Tutti i cluster a partire dalle seguenti versioni della piattaforma utilizzano il nuovo `ClusterRoleBinding`. + Un sottoinsieme di componenti aggiuntivi EKS di è stato convalidato per verificarne la compatibilità con Amazon EKS Hybrid Nodes. AWS Per ulteriori informazioni, consultare la tabella di compatibilità alla pagina [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). ## Namespace personalizzato per componenti aggiuntivi Per la community e AWS i componenti aggiuntivi, puoi facoltativamente specificare uno spazio dei nomi personalizzato durante la creazione del componente aggiuntivo. Una volta installato un componente aggiuntivo in un namespace specifico, è necessario rimuovere e creare nuovamente il componente per modificarne il namespace. Se non viene specificato un namespace, verrà utilizzato il namespace predefinito del componente aggiuntivo. Utilizzare namespace personalizzati per una migliore organizzazione e un miglior isolamento degli oggetti del componente aggiuntivo all’interno del cluster EKS. Questa flessibilità consente di conformare i componenti aggiuntivi alle esigenze operative e alla strategia di namespace esistente. È possibile impostare un namespace personalizzato durante la creazione di un componente aggiuntivo. Per ulteriori informazioni, consulta [Creare un componente aggiuntivo Amazon EKS](creating-an-add-on.md). ### Ottenere un namespace predefinito di un componente aggiuntivo Il namespace predefinito di un componente aggiuntivo è il namespace in cui sarà installato se non ne viene specificato uno. Utilizzare il seguente comando per ottenere il namespace predefinito di un componente aggiuntivo: ``` aws eks describe-addon-versions --addon-name --query "addons[].defaultNamespace" ``` Output di esempio: ``` [ "kube-system" ] ``` ## Considerazioni per la modalità automatica di Amazon EKS La modalità automatica di Amazon EKS include funzionalità che garantiscono l’operatività essenziale del cluster, tra cui: + Reti pod + Reti di servizio + DNS del cluster + Dimensionamento automatico + Storage a blocchi + Controller del bilanciatore del carico + Agente Pod Identity + Agente di monitoraggio del nodo Con il calcolo in modalità automatica, molti dei componenti aggiuntivi EKS più utilizzati diventano ridondanti, come: + CNI di Amazon VPC + kube-proxy + CoreDNS + Driver CSI per Amazon EBS + EKS Pod Identity Agent Tuttavia, se il cluster combina la modalità Auto con altre opzioni di elaborazione come EC2 istanze autogestite, Gruppi di nodi gestiti o AWS Fargate, questi componenti aggiuntivi rimangono necessari. AWS ha migliorato i componenti aggiuntivi EKS con regole anti-affinità che garantiscono automaticamente la pianificazione dei pod aggiuntivi solo sui tipi di elaborazione supportati. Inoltre, ora gli utenti possono ora utilizzare l’API `DescribeAddonVersions` dei componenti aggiuntivi EKS per verificare i tipi di calcolo supportati (computeTypes) per ciascun componente aggiuntivo e le relative versioni specifiche. Inoltre, con la modalità EKS Auto, i controller sopra elencati funzionano su un'infrastruttura di proprietà. AWS Di conseguenza, potrebbero non essere nemmeno visibili negli account, a meno che non si utilizzi la modalità automatica EKS con altri tipi di calcolo. In tal caso, i controller installati sul cluster saranno visibili. Se si intende abilitare la modalità automatica EKS su un cluster esistente, potrebbe essere necessario aggiornare la versione di alcuni componenti aggiuntivi. Per ulteriori informazioni, consultare [Versioni richieste del componente aggiuntivo](auto-enable-existing.md#auto-addons-required) per la modalità automatica EKS. ## Supporto AWS pubblica diversi tipi di componenti aggiuntivi con diversi livelli di supporto. + Componenti aggiuntivi AWS : questi componenti aggiuntivi sono creati e completamente supportati da AWS. + Usa un AWS componente aggiuntivo per lavorare con altri AWS servizi, come Amazon EFS. + Per ulteriori informazioni, consulta [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). + AWS Componenti aggiuntivi del Marketplace: questi componenti aggiuntivi vengono analizzati AWS e supportati da un partner indipendente. AWS + Utilizzare un componente aggiuntivo del marketplace per aggiungere funzionalità preziose e sofisticate al cluster, come il monitoraggio con Splunk. + Per ulteriori informazioni, consulta [AWS Componenti aggiuntivi del Marketplace](workloads-add-ons-available-vendors.md). + Componenti aggiuntivi della community: questi componenti aggiuntivi vengono analizzati AWS ma supportati dalla comunità open source. + Utilizzare un componente aggiuntivo della community per ridurre la complessità dell’installazione di software open source comuni, come Kubernetes Metrics Server. + I componenti aggiuntivi della community sono forniti dal codice sorgente di. AWS AWS convalida i componenti aggiuntivi della community solo per la compatibilità delle versioni. + Per ulteriori informazioni, consulta [Componenti aggiuntivi della community](community-addons.md). La tabella seguente illustra la portata del supporto per ogni tipo di componente aggiuntivo: | Categoria | Funzionalità | AWS componenti aggiuntivi | AWS Componenti aggiuntivi del Marketplace | Componenti aggiuntivi della community | | --- | --- | --- | --- | --- | | Sviluppo | Creato da AWS | Sì | No | Sì | | Sviluppo | Convalidato da AWS | Sì | No | Sì\$1 | | Sviluppo | Convalidato dal partner AWS | No | Sì | No | | Maintenance (Manutenzione) | Scansionato da AWS | Sì | Sì | Sì | | Maintenance (Manutenzione) | Patchato da AWS | Sì | No | Sì | | Maintenance (Manutenzione) | Patchato dal partner AWS | No | Sì | No | | Distribuzione | Pubblicato da AWS | Sì | No | Sì | | Distribuzione | Pubblicato da AWS Partner | No | Sì | No | | Supporto | Supporto di installazione di base fornito da AWS | Sì | Sì | Sì | | Supporto | AWS Supporto completo | Sì | No | No | | Supporto | Supporto completo AWS per i partner | No | Sì | No | ``: la convalida dei componenti aggiuntivi della community include solo la compatibilità delle versioni di Kubernetes. Ad esempio, se installi un componente aggiuntivo della community su un cluster, AWS verifica se è compatibile con la versione Kubernetes del cluster. AWS I componenti aggiuntivi di Marketplace possono scaricare dipendenze software aggiuntive da fonti esterne esterne a. AWS Queste dipendenze esterne non vengono analizzate o convalidate da. AWS Considera i tuoi requisiti di sicurezza quando distribuisci componenti aggiuntivi di AWS Marketplace che recuperano dipendenze esterne. # AWS componenti aggiuntivi Nel tuo cluster puoi creare i seguenti componenti aggiuntivi di Amazon EKS. È possibile visualizzare l'elenco più aggiornato dei componenti aggiuntivi disponibili utilizzando `eksctl` Console di gestione AWS, o la AWS CLI. Per visualizzare tutti i componenti aggiuntivi disponibili o per installare un componente aggiuntivo, consulta la pagina [Creare un componente aggiuntivo Amazon EKS](creating-an-add-on.md). Se un componente aggiuntivo richiede autorizzazioni IAM, è necessario disporre di un provider OpenID Connect (OIDC) IAM per il cluster. Per stabilire se ne possiedi uno o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). Puoi creare o eliminare un componente aggiuntivo dopo averlo installato. Per ulteriori informazioni, consulta [Aggiornamento di un componente aggiuntivo di Amazon EKS](updating-an-add-on.md) o [Rimozione di un componente aggiuntivo Amazon EKS da un cluster](removing-an-add-on.md). Per ulteriori informazioni su considerazioni specifiche in merito all’esecuzione di componenti aggiuntivi EKS con Amazon EKS Hybrid Nodes, consulta [Configurare componenti aggiuntivi per nodi ibridi](hybrid-nodes-add-ons.md). È possibile utilizzare uno dei seguenti componenti aggiuntivi di Amazon EKS. | Description | Ulteriori informazioni | Tipi di elaborazione compatibili | | --- | --- | --- | | Fornire una rete VPC nativa per il tuo cluster | [Plug-in della CNI di Amazon VPC per Kubernetes](#add-ons-vpc-cni) | EC2 | | Un server DNS flessibile ed estensibile che può fungere da cluster DNS Kubernetes | [CoreDNS](#add-ons-coredns) | EC2, Fargate, modalità automatica EKS, nodi ibridi EKS | | Mantenere le regole di rete su ciascun nodo Amazon EC2 | [`Kube-proxy`](#add-ons-kube-proxy) | Nodi ibridi EC2, EKS | | Fornisci l’archiviazione Amazon EBS per il cluster | [Driver CSI per Amazon EBS](#add-ons-aws-ebs-csi-driver) | EC2 | | Fornire l’archiviazione Amazon EBS per il cluster | [Driver CSI per Amazon EFS](#add-ons-aws-efs-csi-driver) | EC2, modalità automatica EKS | | Fornisci lo storage Amazon FSx for Lustre per il tuo cluster | [Driver Amazon FSx CSI](#add-ons-aws-fsx-csi-driver) | EC2, modalità automatica EKS | | Fornire l’archiviazione Amazon S3 per il cluster | [Driver CSI di Mountpoint per Amazon S3](#mountpoint-for-s3-add-on) | EC2, modalità automatica EKS | | Rilevare ulteriori problemi di integrità dei nodi | [Agente di monitoraggio del nodo](#add-ons-eks-node-monitoring-agent) | Nodi ibridi EC2, EKS | | Abilitare l’utilizzo della funzionalità snapshot nei driver CSI compatibili, come il driver CSI per Amazon EBS. | [Controller di snapshot CSI](#addons-csi-snapshot-controller) | EC2, Fargate, modalità automatica EKS, nodi ibridi EKS | | SageMaker HyperPod la governance delle attività ottimizza l'allocazione e l'utilizzo delle risorse di calcolo tra i team nei cluster Amazon EKS, risolvendo le inefficienze nella prioritizzazione delle attività e nella condivisione delle risorse. | [Gestione delle SageMaker HyperPod attività di Amazon](#addons-hyperpod) | EC2, modalità automatica EKS, | | Amazon SageMaker HyperPod Observability AddOn offre funzionalità complete di monitoraggio e osservabilità per i HyperPod cluster. | [Componente aggiuntivo Amazon SageMaker HyperPod Observability](#addons-hyperpod-observability) | EC2, modalità automatica EKS, | | L'operatore di SageMaker HyperPod formazione di Amazon consente una formazione distribuita efficiente sui cluster Amazon EKS con funzionalità avanzate di pianificazione e gestione delle risorse. | [Operatore SageMaker HyperPod di formazione Amazon](#addons-hyperpod-training-operator) | EC2, modalità automatica EKS | | Amazon SageMaker HyperPod Inference Operator consente l'implementazione e la gestione di carichi di lavoro di inferenza AI ad alte prestazioni con utilizzo ottimizzato delle risorse ed efficienza dei costi. | [Operatore di SageMaker HyperPod inferenza Amazon](#addons-hyperpod-inference-operator) | EC2, modalità automatica EKS | | Un agente Kubernetes che raccoglie e riporta i dati del flusso di rete ad Amazon CloudWatch, abilitando il monitoraggio completo delle connessioni TCP tra i nodi del cluster. | [AWS Network Flow Monitor Agent](#addons-network-flow) | EC2, modalità automatica EKS | | Distribuzione del progetto sicura, pronta per la produzione e supportata AWS OpenTelemetry | [AWS Distro per OpenTelemetry](#add-ons-adot) | EC2, Fargate, modalità automatica EKS, nodi ibridi EKS | | Servizio di monitoraggio della sicurezza che analizza ed elabora le fonti di dati fondamentali, tra cui eventi di AWS CloudTrail gestione e log di flusso di Amazon VPC. Amazon elabora GuardDuty anche funzionalità, come i log di controllo di Kubernetes e il monitoraggio del runtime | [GuardDuty Agente Amazon](#add-ons-guard-duty) | EC2, modalità automatica EKS | | Servizio di monitoraggio e osservabilità fornito da AWS. Questo componente aggiuntivo installa l' CloudWatch agente e abilita sia CloudWatch Application Signals che CloudWatch Container Insights con una migliore osservabilità per Amazon EKS | [Agente Amazon CloudWatch Observability](#amazon-cloudwatch-observability) | EC2, modalità automatica EKS, nodi ibridi EKS | | Possibilità di gestire le credenziali per le applicazioni, analogamente al modo in cui i profili dell’istanza EC2 forniscono le credenziali alle istanze EC2 | [EKS Pod Identity Agent](#add-ons-pod-id) | Nodi ibridi EC2, EKS | | Abilita cert-manager per emettere certificati X.509 da Private CA. AWS Richiede cert-manager. | [AWS Connettore CA privato per Kubernetes](#add-ons-aws-privateca-connector) | EC2, Fargate, modalità automatica EKS, nodi ibridi EKS | | Genera metriche Prometheus sulle prestazioni dei dispositivi di rete SR-IOV | [Esportatore di metriche di rete SR-IOV](#add-ons-sriov-network-metrics-exporter) | EC2 | | Recupera i AWS segreti da Secrets Manager e i parametri da AWS Systems Manager Parameter Store e montali come file nei pod Kubernetes. | [AWS Fornitore di driver CSI Secrets Store](#add-ons-aws-secrets-store-csi-driver-provider) | EC2, modalità automatica EKS, nodi ibridi EKS | | Con Spaces, puoi creare JupyterLab e gestire applicazioni Code Editor per eseguire carichi di lavoro ML interattivi. | [SageMaker Spazi Amazon](#add-ons-amazon-sagemaker-spaces) | Hyperpod | ## Plug-in della CNI di Amazon VPC per Kubernetes Il componente aggiuntivo Amazon EKS del plugin CNI di Amazon VPC per Kubernetes è un plugin di interfaccia di rete container (CNI) Kubernetes che fornisce una rete VPC nativa per il cluster. Il tipo autogestito o gestito di questo componente aggiuntivo è installato su ogni nodo Amazon EC2 per impostazione predefinita. Per ulteriori informazioni, consulta [Plugin di interfaccia di rete container (CNI) Kubernetes.](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins/) Nota Non è necessario installare questo componente aggiuntivo sui cluster in modalità automatica EKS di Amazon. Per ulteriori informazioni, consulta [Considerazioni per la modalità automatica di Amazon EKS](eks-add-ons.md#addon-consider-auto). Il nome del componente aggiuntivo di Amazon EKS è `vpc-cni`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo utilizza i ruoli IAM per gli account di servizio di Amazon EKS. Per ulteriori informazioni, consulta [Ruoli IAM per gli account di servizio](iam-roles-for-service-accounts.md). Se il cluster utilizza la famiglia `IPv4`, sono necessarie le autorizzazioni in [AmazonEKS\$1CNI\$1Policy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEKS_CNI_Policy.html). [Se il cluster utilizza la `IPv6` famiglia, è necessario [creare una policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) con le autorizzazioni in IPv6 modalità.](https://github.com/aws/amazon-vpc-cni-k8s/blob/master/docs/iam-policy.md#ipv6-mode) È possibile creare un ruolo IAM, collegare una delle policy e annotare l’account del servizio Kubernetes utilizzato dal componente aggiuntivo con il comando seguente. Sostituisci my-cluster* con il nome del cluster e AmazonEKSVPCCNIRole con il nome del ruolo. Se il tuo cluster utilizza la famiglia `IPv6`, sostituisci AmazonEKS\$1CNI\$1Policy con il nome della policy che hai creato. Questo comando richiede che [eksctl](https://eksctl.io) sia installato sul tuo dispositivo. Se devi utilizzare uno strumento diverso per creare il ruolo, collegarvi la policy e annotare l’account del servizio Kubernetes, consulta [Assegnare ruoli IAM agli account di servizio Kubernetes](associate-service-account-role.md). ``` eksctl create iamserviceaccount --name aws-node --namespace kube-system --cluster my-cluster --role-name AmazonEKSVPCCNIRole \ --role-only --attach-policy-arn arn:aws: iam::aws:policy/AmazonEKS_CNI_Policy --approve ``` ### Aggiornare le informazioni Puoi aggiornare solo una versione secondaria alla volta. Ad esempio, se la versione corrente è `1.28.x-eksbuild.y ` e desideri aggiornarla a `1.30.x-eksbuild.y `, devi prima eseguire l'aggiornamento a `1.29.x-eksbuild.y ` e quindi l'aggiornamento a `1.30.x-eksbuild.y `. Per ulteriori informazioni sull'aggiornamento del componente aggiuntivo, consulta [Aggiornamento di CNI di Amazon VPC (componente aggiuntivo Amazon EKS)](vpc-add-on-update.md). ## CoreDNS Il componente aggiuntivo CoreDNS per Amazon EKS è un server DNS flessibile ed estensibile che può fungere da DNS del cluster di Kubernetes. Il tipo autogestito o gestito di questo componente aggiuntivo è stato installato, per impostazione predefinita, al momento della creazione del cluster. Quando si avvia un cluster Amazon EKS con almeno un nodo, due repliche dell’immagine CoreDNS vengono distribuite per impostazione predefinita, indipendentemente dal numero di nodi distribuiti nel cluster. I contenitori CoreDNS forniscono la risoluzione dei nomi per tutti i pod del cluster. È possibile implementare i pod CoreDNS ai nodi Fargate se il cluster include un profilo Fargate con uno namespace che corrisponde al namespace per l’implementazione di CoreDNS. Per ulteriori informazioni, consulta [Definisci quali pod utilizzano AWS Fargate durante l’avvio](fargate-profile.md) Nota Non è necessario installare questo componente aggiuntivo sui cluster in modalità automatica EKS di Amazon. Per ulteriori informazioni, consulta [Considerazioni per la modalità automatica di Amazon EKS](eks-add-ons.md#addon-consider-auto). Il nome del componente aggiuntivo di Amazon EKS è `coredns`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo non richiede alcuna autorizzazione. ### Informazioni aggiuntive Per ulteriori informazioni su CoreDNS, consulta [Utilizzo di CoreDNS per il rilevamento servizi](https://kubernetes.io/docs/tasks/administer-cluster/coredns/) e [Personalizzazione del servizio DNS](https://kubernetes.io/docs/tasks/administer-cluster/dns-custom-nameservers/) nella documentazione di Kubernetes. ## `Kube-proxy` Il componente aggiuntivo di Amazon EKS `Kube-proxy` mantiene le regole di rete su ciascun nodo Amazon EC2. Consente la comunicazione di rete con i tuoi pod. Il tipo autogestito o gestito di questo componente aggiuntivo è installato su ogni nodo Amazon EC2 nel cluster per impostazione predefinita. Nota Non è necessario installare questo componente aggiuntivo sui cluster in modalità automatica EKS di Amazon. Per ulteriori informazioni, consulta [Considerazioni per la modalità automatica di Amazon EKS](eks-add-ons.md#addon-consider-auto). Il nome del componente aggiuntivo di Amazon EKS è `kube-proxy`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo non richiede alcuna autorizzazione. ### Aggiornare le informazioni Prima di aggiornare la versione corrente, considera i seguenti requisiti: + `Kube-proxy` su un cluster Amazon EKS ha la stessa [policy di compatibilità e disallineamento di Kubernetes](https://kubernetes.io/releases/version-skew-policy/#kube-proxy). ### Informazioni aggiuntive Per ulteriori informazioni su `kube-proxy`, consulta [kube-proxy](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-proxy/) nella documentazione Kubernetes. ## Driver CSI per Amazon EBS Il componente aggiuntivo di Amazon EKS per il driver CSI per Amazon EBS è un plugin di interfaccia di archiviazione del container (CSI) Kubernetes che fornisce archiviazione Amazon EBS per il cluster. Nota Non è necessario installare questo componente aggiuntivo sui cluster in modalità automatica EKS di Amazon. La modalità automatica include una funzionalità di archiviazione a blocchi. Per ulteriori informazioni, consulta [Implementazione di un carico di lavoro stateful esemplificativo in modalità automatica EKS](sample-storage-workload.md). Il nome del componente aggiuntivo di Amazon EKS è `aws-ebs-csi-driver`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo usa i ruoli IAM per gli account di servizio di Amazon EKS. Per ulteriori informazioni, consulta [Ruoli IAM per gli account di servizio](iam-roles-for-service-accounts.md). Le autorizzazioni nella [EBSCSIDriverpolitica AWS gestita da Amazon Policy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEBSCSIDriverPolicy.html) sono obbligatorie. Puoi creare un ruolo IAM e collegarvi la policy gestita con il seguente comando. Sostituisci my-cluster con il nome del cluster e AmazonEKS\$1EBS\$1CSI\$1DriverRole con il nome del ruolo. Questo comando richiede che [eksctl](https://eksctl.io) sia installato sul tuo dispositivo. Se hai la necessità di utilizzare uno strumento diverso o una [chiave KMS](https://aws.amazon.com/kms/) personalizzata per la crittografia, consulta la sezione [Passaggio 1: Creazione di un ruolo IAM](ebs-csi.md#csi-iam-role). ``` eksctl create iamserviceaccount \ --name ebs-csi-controller-sa \ --namespace kube-system \ --cluster my-cluster \ --role-name AmazonEKS_EBS_CSI_DriverRole \ --role-only \ --attach-policy-arn arn:aws: iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \ --approve ``` ### Informazioni aggiuntive Per ulteriori informazioni sul componente aggiuntivo, consulta [Utilizzare il volume di archiviazione Kubernetes con Amazon EBS](ebs-csi.md). ## Driver CSI per Amazon EFS Il componente aggiuntivo di Amazon EKS per il driver EFS per Amazon EBS è un plugin di interfaccia di archiviazione del container (CSI) Kubernetes che fornisce archiviazione Amazon EFS per il cluster. Il nome del componente aggiuntivo di Amazon EKS è `aws-efs-csi-driver`. ### Autorizzazioni IAM richieste Autorizzazioni IAM richieste: questo componente aggiuntivo usa la funzionalità Ruoli IAM per gli account di servizio di Amazon EKS. Per ulteriori informazioni, consulta [Ruoli IAM per gli account di servizio](iam-roles-for-service-accounts.md). Le autorizzazioni nella [EFSCSIDriverpolitica AWS gestita da Amazon Policy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEFSCSIDriverPolicy.html) sono obbligatorie. Puoi creare un ruolo IAM e collegarvi la policy gestita con i seguenti comandi. Sostituisci my-cluster con il nome del cluster e AmazonEKS\$1EFS\$1CSI\$1DriverRole con il nome del ruolo. Questi comandi richiedono l’installazione di [eksctl](https://eksctl.io) sul tuo dispositivo. Se hai bisogno di usare uno strumento diverso, vedi [Passaggio 1: Creazione di un ruolo IAM](efs-csi.md#efs-create-iam-resources). ``` export cluster_name=my-cluster export role_name=AmazonEKS_EFS_CSI_DriverRole eksctl create iamserviceaccount \ --name efs-csi-controller-sa \ --namespace kube-system \ --cluster $cluster_name \ --role-name $role_name \ --role-only \ --attach-policy-arn arn:aws: iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy \ --approve TRUST_POLICY=$(aws iam get-role --output json --role-name $role_name --query 'Role.AssumeRolePolicyDocument' | \ sed -e 's/efs-csi-controller-sa/efs-csi-/' -e 's/StringEquals/StringLike/') aws iam update-assume-role-policy --role-name $role_name --policy-document "$TRUST_POLICY" ``` ### Informazioni aggiuntive Per ulteriori informazioni sul componente aggiuntivo, consulta [Utilizzo dell’archiviazione di file system elastici con Amazon EFS](efs-csi.md). ## Driver Amazon FSx CSI Il driver Amazon FSx CSI (componente aggiuntivo Amazon EKS) è un plug-in Kubernetes Container Storage Interface (CSI) che fornisce lo storage Amazon for Lustre FSx per il tuo cluster. Il nome del componente aggiuntivo di Amazon EKS è `aws-fsx-csi-driver`. Nota Le installazioni preesistenti di driver Amazon FSx CSI nel cluster possono causare errori di installazione dei componenti aggiuntivi. Quando tenti di installare la versione del componente aggiuntivo Amazon EKS mentre esiste un driver FSx CSI non EKS, l'installazione avrà esito negativo a causa di conflitti di risorse. Usa il flag `OVERWRITE` durante l’installazione per risolvere il problema: ``` aws eks create-addon --addon-name aws-fsx-csi-driver --cluster-name my-cluster --resolve-conflicts OVERWRITE ``` Il componente aggiuntivo Amazon FSx CSI Driver EKS richiede l'agente EKS Pod Identity per l'autenticazione. Senza questo componente, il componente aggiuntivo fallirà con l’errore `Amazon EKS Pod Identity agent is not installed in the cluster`, impedendo le operazioni di volume. Installa l'agente Pod Identity prima o dopo la distribuzione del componente aggiuntivo FSx CSI Driver. Per ulteriori informazioni, consulta [Configurazione dell’agente Amazon EKS Pod Identity](pod-id-agent-setup.md). ### Autorizzazioni IAM richieste Questo componente aggiuntivo usa i ruoli IAM per gli account di servizio di Amazon EKS. Per ulteriori informazioni, consulta [Ruoli IAM per gli account di servizio](iam-roles-for-service-accounts.md). Le autorizzazioni nella policy FSx FullAccess AWS gestita da [Amazon](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonFSxFullAccess.html) sono obbligatorie. Puoi creare un ruolo IAM e collegarvi la policy gestita con il seguente comando. Sostituisci my-cluster* con il nome del cluster e AmazonEKS\$1FSx\$1CSI\$1DriverRole con il nome del ruolo. Questo comando richiede che [eksctl](https://eksctl.io) sia installato sul tuo dispositivo. ``` eksctl create iamserviceaccount \ --name fsx-csi-controller-sa \ --namespace kube-system \ --cluster my-cluster \ --role-name AmazonEKS_FSx_CSI_DriverRole \ --role-only \ --attach-policy-arn arn:aws: iam::aws:policy/AmazonFSxFullAccess \ --approve ``` ### Informazioni aggiuntive Per ulteriori informazioni sul componente aggiuntivo, consulta [Usa l’archiviazione delle app ad alte prestazioni con Amazon FSx per Lustre](fsx-csi.md). ## Driver CSI di Mountpoint per Amazon S3 Il componente aggiuntivo Mountpoint per Amazon S3 di Amazon EKS per il driver CSI è un plugin di interfaccia di archiviazione del container (CSI) Kubernetes che fornisce archiviazione Amazon S3 per il cluster. Il nome del componente aggiuntivo di Amazon EKS è `aws-mountpoint-s3-csi-driver`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo utilizza i ruoli IAM per gli account di servizio di Amazon EKS. Per ulteriori informazioni, consulta [Ruoli IAM per gli account di servizio](iam-roles-for-service-accounts.md). Il ruolo IAM creato richiederà una policy che fornisca l'accesso a S3. Segui i [Suggerimenti sulle autorizzazioni IAM di Mountpoint](https://github.com/awslabs/mountpoint-s3/blob/main/doc/CONFIGURATION.md#iam-permissions) durante la creazione della policy. In alternativa, puoi utilizzare la politica AWS gestita [AmazonS3 FullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonS3FullAccess$jsonEditor), ma questa politica gestita concede più autorizzazioni di quelle necessarie per Mountpoint. Puoi creare un ruolo IAM e collegarvi la policy gestita con i seguenti comandi. Sostituisci my-cluster con il nome del cluster, region-code con il codice AWS regionale corretto, AmazonEKS\$1S3\$1CSI\$1DriverRole con il nome del tuo ruolo e AmazonEKS\$1S3\$1CSI\$1DriverRole\$1ARN con il ruolo ARN. Questi comandi richiedono l’installazione di [eksctl](https://eksctl.io) sul tuo dispositivo. Per istruzioni sull'uso della console IAM o della AWS CLI, consulta. [Fase 2: creazione di un ruolo IAM](s3-csi-create.md#s3-create-iam-role) ``` CLUSTER_NAME=my-cluster REGION=region-code ROLE_NAME=AmazonEKS_S3_CSI_DriverRole POLICY_ARN=AmazonEKS_S3_CSI_DriverRole_ARN eksctl create iamserviceaccount \ --name s3-csi-driver-sa \ --namespace kube-system \ --cluster $CLUSTER_NAME \ --attach-policy-arn $POLICY_ARN \ --approve \ --role-name $ROLE_NAME \ --region $REGION \ --role-only ``` ### Informazioni aggiuntive Per ulteriori informazioni sul componente aggiuntivo, consulta [Accedere agli oggetti Amazon S3 con il driver CSI Mountpoint per Amazon S3](s3-csi.md). ## Controller di snapshot CSI Il controller di snapshot dell’interfaccia di archiviazione di container (CSI) consente l’uso della funzionalità snapshot nei driver CSI compatibili, come il driver CSI di Amazon EBS. Il nome del componente aggiuntivo di Amazon EKS è `snapshot-controller`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo non richiede alcuna autorizzazione. ### Informazioni aggiuntive Per ulteriori informazioni sul componente aggiuntivo, consulta [Abilitare la funzionalità snapshot per i volumi CSI](csi-snapshot-controller.md). ## Gestione delle SageMaker HyperPod attività di Amazon SageMaker HyperPod la governance delle attività è un robusto sistema di gestione progettato per semplificare l'allocazione delle risorse e garantire un utilizzo efficiente delle risorse di elaborazione tra team e progetti per i cluster Amazon EKS. Questa funzionalità offre agli amministratori la possibilità di impostare: + Livelli di priorità per varie attività + Allocazione delle risorse di calcolo per ogni team + In che modo ogni team presta e prende in prestito risorse di calcolo inattive + Se un team rende prerilasciabili le proprie attività HyperPod la governance delle attività fornisce anche l'osservabilità del cluster Amazon EKS, offrendo visibilità in tempo reale sulla capacità del cluster. Ciò include la disponibilità e l’utilizzo delle risorse di calcolo, l’allocazione e l’utilizzo del team e le informazioni sull’esecuzione delle attività e sui tempi di attesa, per consentirti di prendere decisioni informate e gestire in modo proattivo le risorse. Il nome del componente aggiuntivo di Amazon EKS è `amazon-sagemaker-hyperpod-taskgovernance`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo non richiede alcuna autorizzazione. ### Informazioni aggiuntive [Per ulteriori informazioni sul componente aggiuntivo, consulta SageMaker HyperPod la sezione Task Governance](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-eks-operate-console-ui-governance.html) ## Componente aggiuntivo Amazon SageMaker HyperPod Observability L'Amazon SageMaker HyperPod Observability Add-on offre funzionalità complete di monitoraggio e osservabilità per i cluster. HyperPod Questo componente aggiuntivo distribuisce e gestisce automaticamente i componenti di monitoraggio essenziali, tra cui Node Exporter, DCGM Exporter ed EFA Exporter. kube-state-metrics Raccoglie e inoltra i parametri a un’istanza Prometheus gestita da Amazon (AMP) designata dal cliente ed espone un endpoint OTLP per metriche personalizzate e acquisizione di eventi dai job di addestramento dei clienti. Il componente aggiuntivo si integra con l' HyperPod ecosistema più ampio estrapolando le metriche da vari componenti, tra cui il componente aggiuntivo Task Governance, Training Operator, Kubeflow e KEDA. HyperPod HyperPod Tutte le metriche raccolte sono centralizzate in Prometheus gestito da Amazon, che consente ai clienti di ottenere una visione unificata dell’osservabilità tramite i dashboard di Grafana gestito da Amazon. Ciò fornisce end-to-end visibilità sullo stato del cluster, sull'utilizzo delle risorse e sulle prestazioni lavorative di formazione in tutto l'ambiente. HyperPod Il nome del componente aggiuntivo di Amazon EKS è `amazon-sagemaker-hyperpod-observability`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo utilizza i ruoli IAM per gli account di servizio di Amazon EKS. Per ulteriori informazioni, consulta [Ruoli IAM per gli account di servizio](iam-roles-for-service-accounts.md). Di seguito sono elencate le policy gestite richieste: + `AmazonPrometheusRemoteWriteAccess`: per la scrittura remota delle metriche a partire dal cluster fino ad AMP + `CloudWatchAgentServerPolicy`- per la scrittura remota dei log dal cluster a CloudWatch ### Informazioni aggiuntive [Per ulteriori informazioni sul componente aggiuntivo e sulle sue funzionalità, consulta SageMaker HyperPod Observability.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-eks-cluster-observability-cluster.html) ## Operatore SageMaker HyperPod di formazione Amazon L'operatore di SageMaker HyperPod formazione di Amazon ti aiuta ad accelerare lo sviluppo di modelli di intelligenza artificiale generativi gestendo in modo efficiente la formazione distribuita su cluster di GPU di grandi dimensioni. Introduce funzionalità intelligenti di ripristino dai guasti, rilevamento delle interruzioni e gestione a livello di processo che riducono al minimo le interruzioni dell’addestramento e riducono i costi. A differenza dell’infrastruttura di addestramento tradizionale che richiede il riavvio completo del processo in caso di guasto, questo operatore implementa un ripristino chirurgico del processo per garantire il corretto funzionamento dei job di addestramento. L'operatore collabora anche con le funzioni di monitoraggio HyperPod dello stato di salute e osservabilità, fornendo visibilità in tempo reale sull'esecuzione della formazione e il monitoraggio automatico di parametri critici come i picchi di perdita e il degrado della produttività. Puoi definire le policy di ripristino tramite semplici configurazioni YAML senza modifiche al codice, che consentono di rispondere rapidamente e ripristinare gli stati irreversibili dell’addestramento. Queste funzionalità di monitoraggio e ripristino interagiscono per garantire prestazioni di addestramento ottimali riducendo al minimo il sovraccarico operativo. Il nome del componente aggiuntivo di Amazon EKS è `amazon-sagemaker-hyperpod-training-operator`. Per ulteriori informazioni, consulta [Using the HyperPod training operator](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-operator.html) nella Amazon SageMaker Developer Guide. ### Autorizzazioni IAM richieste Questo componente aggiuntivo richiede le autorizzazioni IAM e utilizza EKS Pod Identity. AWS suggerisce la [politica `AmazonSageMakerHyperPodTrainingOperatorAccess` gestita](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerHyperPodTrainingOperatorAccess.html). Per ulteriori informazioni, consulta [Installazione dell'operatore di formazione](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-operator-install.html#sagemaker-eks-operator-install-operator) nella Amazon SageMaker Developer Guide. ### Informazioni aggiuntive Per ulteriori informazioni sul componente aggiuntivo, consulta [SageMaker HyperPod Training Operator](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-eks-operator.html). ## Operatore di SageMaker HyperPod inferenza Amazon Amazon SageMaker HyperPod offre un' end-to-endesperienza che supporta l'intero ciclo di vita dello sviluppo dell'intelligenza artificiale, dalla sperimentazione e formazione interattive ai flussi di lavoro di inferenza e post-formazione. Ora fornisce una piattaforma di inferenza completa che combina la flessibilità di Kubernetes con l'eccellenza operativa di un'esperienza gestita. Implementa, ridimensiona e ottimizza i tuoi modelli GenAI con affidabilità di livello aziendale utilizzando lo stesso calcolo per l'intero ciclo di vita del modello. HyperPod Amazon SageMaker HyperPod offre interfacce di distribuzione flessibili che consentono di distribuire modelli tramite diversi metodi, tra cui kubectl, Python SDK, Amazon SageMaker Studio UI o CLI. HyperPod La funzionalità offre funzionalità di scalabilità automatica avanzate con allocazione dinamica delle risorse che si adatta automaticamente in base alla domanda. Inoltre, include funzionalità complete di osservabilità e monitoraggio che tengono traccia di metriche critiche come la latenza e l'utilizzo della time-to-first-token GPU per aiutarti a ottimizzare le prestazioni. Il nome del componente aggiuntivo di Amazon EKS è `amazon-sagemaker-hyperpod-inference`. ### Metodi di installazione È possibile installare questo componente aggiuntivo utilizzando uno dei seguenti metodi: + SageMaker Console (consigliata): offre un'esperienza di installazione semplificata con configurazione guidata. + Console dei componenti aggiuntivi EKS o CLI: richiede l'installazione manuale dei componenti aggiuntivi di dipendenza prima di installare l'operatore di inferenza. Per informazioni sulle dipendenze richieste, consulta la sezione relativa ai prerequisiti di seguito. ### Prerequisiti Prima di installare il componente aggiuntivo dell'operatore di inferenza tramite la console EKS Add-ons o la CLI, assicurati che siano installate le seguenti dipendenze. Componenti aggiuntivi EKS richiesti: + Driver CSI Amazon S3 Mountpoint (versione minima: v1.14.1-eksbuild.1) + Metrics Server (versione minima: v0.7.2-eksbuild.4) + Amazon FSx CSI Driver (versione minima: v1.6.0-eksbuild.1) + Cert Manager (versione minima: v1.18.2-eksbuild.2) [Per istruzioni di installazione dettagliate per ciascuna dipendenza, vedere Installazione dell'operatore di inferenza.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-model-deployment-setup.html) ### Autorizzazioni IAM richieste Questo componente aggiuntivo richiede le autorizzazioni IAM e utilizza OIDC/IRSA. Le seguenti politiche gestite sono consigliate in quanto forniscono le autorizzazioni con ambito minimo: + `AmazonSageMakerHyperPodInferenceAccess`- fornisce i privilegi di amministratore necessari per configurare l'operatore di inferenza + `AmazonSageMakerHyperPodGatedModelAccess`- fornisce SageMaker HyperPod l'accesso a modelli chiusi in SageMaker Jumpstart (ad esempio, Meta Llama, GPT-Neo) [Per ulteriori informazioni, vedere Installazione dell'operatore di inferenza.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-model-deployment-setup.html) ### Informazioni aggiuntive Per ulteriori informazioni sull'operatore di SageMaker HyperPod inferenza di Amazon, consulta operatore di [SageMaker HyperPod inferenza.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-model-deployment.html) Per informazioni sulla risoluzione dei problemi, consulta [Risoluzione dei problemi di distribuzione SageMaker HyperPod del modello](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-model-deployment-ts.html). ## AWS Network Flow Monitor Agent Amazon CloudWatch Network Flow Monitor Agent è un'applicazione Kubernetes che raccoglie le statistiche di connessione TCP da tutti i nodi di un cluster e pubblica report sul flusso di rete su Amazon Network Flow Monitor Ingestion. CloudWatch APIs Il nome del componente aggiuntivo di Amazon EKS è `aws-network-flow-monitoring-agent`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo richiede autorizzazioni IAM. Quindi, è necessario aggiungere la policy gestita da `CloudWatchNetworkFlowMonitorAgentPublishPolicy` a tale componente aggiuntivo. Per ulteriori informazioni sulla configurazione IAM richiesta, consulta [IAM Policy](https://github.com/aws/network-flow-monitor-agent?tab=readme-ov-file#iam-policy) nel GitHub repository Amazon CloudWatch Network Flow Monitor Agent. Per ulteriori informazioni sulla policy gestita, consulta [CloudWatchNetworkFlowMonitorAgentPublishPolicy](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/security-iam-awsmanpol-network-flow-monitor.html#security-iam-awsmanpol-CloudWatchNetworkFlowMonitorAgentPublishPolicy)la Amazon CloudWatch User Guide. ### Informazioni aggiuntive Per ulteriori informazioni sul componente aggiuntivo, consulta il repository [Amazon CloudWatch Network Flow Monitor Agent GitHub ](https://github.com/aws/network-flow-monitor-agent?tab=readme-ov-file). ## Agente di monitoraggio del nodo Il componente aggiuntivo Amazon EKS dell’agente di monitoraggio dei nodi è in grado di rilevare ulteriori problemi di integrità dei nodi. Questi segnali di integrità aggiuntivi possono essere sfruttati anche dalla funzione opzionale di riparazione automatica dei nodi per sostituire automaticamente i nodi secondo necessità. Nota Non è necessario installare questo componente aggiuntivo sui cluster in modalità automatica EKS di Amazon. Per ulteriori informazioni, consulta [Considerazioni per la modalità automatica di Amazon EKS](eks-add-ons.md#addon-consider-auto). Il nome del componente aggiuntivo di Amazon EKS è `eks-node-monitoring-agent`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo non richiede alcuna autorizzazione supplementare. ### Informazioni aggiuntive Per ulteriori informazioni, consulta [Rileva i problemi di integrità dei nodi e abilita la riparazione automatica dei nodi](node-health.md). ## AWS Distro per OpenTelemetry Il componente aggiuntivo AWS Distro for OpenTelemetry Amazon EKS è una distribuzione del progetto sicura, pronta per la produzione e AWS supportata. OpenTelemetry [Per ulteriori informazioni, consulta AWS Distro for on. OpenTelemetry](https://aws-otel.github.io/) GitHub Il nome del componente aggiuntivo di Amazon EKS è `adot`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo richiede le autorizzazioni IAM solo se si utilizza una delle risorse personalizzate preconfigurate a cui è possibile accedere tramite la configurazione avanzata. ### Informazioni aggiuntive Per ulteriori informazioni, consulta [Getting Started with AWS Distro for OpenTelemetry use EKS Add-Ons](https://aws-otel.github.io/docs/getting-started/adot-eks-add-on) nella AWS Distro per la documentazione. OpenTelemetry ADOT richiede che il `cert-manager` componente aggiuntivo sia distribuito nel cluster come prerequisito, altrimenti questo componente aggiuntivo non funzionerà se distribuito direttamente tramite https://registry.terraform. io/modules/terraform-aws-modules/eks/aws/latest`cluster_addons`proprietà. Per ulteriori requisiti, consulta [Requisiti per iniziare a AWS OpenTelemetry usare i componenti aggiuntivi EKS nella AWS distribuzione per](https://aws-otel.github.io/docs/getting-started/adot-eks-add-on/requirements) la documentazione. OpenTelemetry ## GuardDuty Agente Amazon Il componente aggiuntivo Amazon EKS per l' GuardDuty agente Amazon raccoglie [gli eventi di runtime](https://docs.aws.amazon.com/guardduty/latest/ug/runtime-monitoring-collected-events.html) (accesso ai file, esecuzione dei processi, connessioni di rete) dai nodi del cluster EKS per l'analisi tramite GuardDuty Runtime Monitoring. GuardDuty stesso (non l'agente) è il servizio di monitoraggio della sicurezza che analizza ed elabora le [fonti di dati fondamentali](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_data-sources.html), tra cui gli eventi di AWS CloudTrail gestione e i log di flusso di Amazon VPC, oltre a [funzionalità](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty-features-activation-model.html) come i log di controllo di Kubernetes e il monitoraggio del runtime. Il nome del componente aggiuntivo di Amazon EKS è `aws-guardduty-agent`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo non richiede alcuna autorizzazione. ### Informazioni aggiuntive Per ulteriori informazioni, consulta [Runtime Monitoring per i cluster Amazon EKS in Amazon GuardDuty](https://docs.aws.amazon.com/guardduty/latest/ug/how-runtime-monitoring-works-eks.html). + Per rilevare potenziali minacce alla sicurezza nei cluster Amazon EKS, abilita il monitoraggio del GuardDuty runtime di Amazon e distribuisci l'agente GuardDuty di sicurezza nei cluster Amazon EKS. ## Agente Amazon CloudWatch Observability L'agente Amazon CloudWatch Observability Amazon EKS è il componente aggiuntivo del servizio di monitoraggio e osservabilità fornito da. AWS Questo componente aggiuntivo installa l' CloudWatch agente e abilita sia CloudWatch Application Signals che CloudWatch Container Insights con una migliore osservabilità per Amazon EKS. Per ulteriori informazioni, consulta [Amazon CloudWatch Agent](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html). Il nome del componente aggiuntivo di Amazon EKS è `amazon-cloudwatch-observability`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo utilizza i ruoli IAM per gli account di servizio di Amazon EKS. Per ulteriori informazioni, consulta [Ruoli IAM per gli account di servizio](iam-roles-for-service-accounts.md). Le autorizzazioni incluse nelle politiche [AWSXrayWriteOnlyAccess[CloudWatchAgentServerPolicy](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy)](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXrayWriteOnlyAccess) AWS gestite sono obbligatorie. È possibile creare un ruolo IAM, collegarvi una delle policy gestite e annotare l’account del servizio Kubernetes utilizzato dal componente aggiuntivo con il comando seguente. Sostituisci my-cluster con il nome del cluster e AmazonEKS\$1Observability\$1role con il nome del ruolo. Questo comando richiede che [eksctl](https://eksctl.io) sia installato sul tuo dispositivo. Se devi utilizzare uno strumento diverso per creare il ruolo, collegarvi la policy e annotare l’account del servizio Kubernetes, consulta [Assegnare ruoli IAM agli account di servizio Kubernetes](associate-service-account-role.md). ``` eksctl create iamserviceaccount \ --name cloudwatch-agent \ --namespace amazon-cloudwatch \ --cluster my-cluster \ --role-name AmazonEKS_Observability_Role \ --role-only \ --attach-policy-arn arn:aws: iam::aws:policy/AWSXrayWriteOnlyAccess \ --attach-policy-arn arn:aws: iam::aws:policy/CloudWatchAgentServerPolicy \ --approve ``` ### Informazioni aggiuntive Per ulteriori informazioni, consulta [Installare l' CloudWatch agente.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/install-CloudWatch-Observability-EKS-addon.html) ## AWS Connettore CA privato per Kubernetes Il AWS Private CA Connector for Kubernetes è un componente aggiuntivo per cert-manager che consente agli utenti di ottenere certificati da Private Certificate Authority (Private CA). AWS AWS + Il nome del componente aggiuntivo di Amazon EKS è `aws-privateca-connector-for-kubernetes`. + Il namespace del componente aggiuntivo è `aws-privateca-issuer`. Questo componente aggiuntivo richiede `cert-manager`. `cert-manager` è disponibile su Amazon EKS come componente aggiuntivo della community. Per ulteriori informazioni su questo componente aggiuntivo, consulta [Gestione certificati](community-addons.md#addon-cert-manager). Per ulteriori informazioni sui componenti aggiuntivi di installazione, consulta [Creare un componente aggiuntivo Amazon EKS](creating-an-add-on.md). ### Autorizzazioni IAM richieste Questo componente aggiuntivo richiede autorizzazioni IAM. Usa EKS Pod Identity per collegare la policy IAM `AWSPrivateCAConnectorForKubernetesPolicy` all’account del servizio Kubernetes `aws-privateca-issuer`. Per ulteriori informazioni, consulta [Utilizzo di Pod Identity per assegnare un ruolo IAM a un componente aggiuntivo Amazon EKS](update-addon-role.md). Per informazioni sulle autorizzazioni richieste, consulta il Managed Policy Reference. [AWSPrivateCAConnectorForKubernetesPolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSPrivateCAConnectorForKubernetesPolicy.html) AWS ### Informazioni aggiuntive Per ulteriori informazioni, consulta l'archivio [AWS Private CA Issuer for GitHub Kubernetes](https://github.com/cert-manager/aws-privateca-issuer). [Per ulteriori informazioni sulla configurazione del componente aggiuntivo, consulta values.yaml nel repository.](https://github.com/cert-manager/aws-privateca-issuer/blob/main/charts/aws-pca-issuer/values.yaml) `aws-privateca-issuer` GitHub Verifica che la versione di values.yaml corrisponda alla versione del componente aggiuntivo installato sul cluster. Questo componente aggiuntivo tollera la contaminazione utilizzata dalla modalità automatica EKS. `CriticalAddonsOnly` `system` NodePool Per ulteriori informazioni, consulta [Eseguire componenti aggiuntivi critici su istanze dedicate](critical-workload.md). ## EKS Pod Identity Agent Il componente aggiuntivo di Amazon EKS dell’agente Pod Identity fornisce la possibilità di gestire le credenziali per le applicazioni, analogamente al modo in cui i profili dell’istanza Amazon EC2 forniscono le credenziali alle istanze Amazon EC2. Nota Non è necessario installare questo componente aggiuntivo sui cluster in modalità automatica EKS di Amazon. La modalità automatica EKS di Amazon si integra con Pod Identity EKS. Per ulteriori informazioni, consulta [Considerazioni per la modalità automatica di Amazon EKS](eks-add-ons.md#addon-consider-auto). Il nome del componente aggiuntivo di Amazon EKS è `eks-pod-identity-agent`. ### Autorizzazioni IAM richieste Il componente aggiuntivo dell’agente Pod Identity di per sé non richiede un ruolo IAM. Utilizza le autorizzazioni del [ruolo IAM del nodo Amazon EKS](create-node-role.md) per funzionare, ma non necessita di un ruolo IAM dedicato per il componente aggiuntivo. ### Aggiornare le informazioni Puoi aggiornare solo una versione secondaria alla volta. Ad esempio, se la versione corrente è `1.28.x-eksbuild.y` e desideri aggiornarla a `1.30.x-eksbuild.y`, devi prima eseguire l'aggiornamento a `1.29.x-eksbuild.y` e quindi l'aggiornamento a `1.30.x-eksbuild.y`. Per ulteriori informazioni sull'aggiornamento del componente aggiuntivo, consulta [Aggiornamento di un componente aggiuntivo di Amazon EKS](updating-an-add-on.md). ## Esportatore di metriche di rete SR-IOV Il componente aggiuntivo di Amazon EKS dell’esportazione di metriche di rete SR-IOV raccoglie ed espone le metriche sui dispositivi di rete SR-IOV in formato Prometheus. Consente il monitoraggio delle prestazioni della rete SR-IOV su nodi bare metal EKS. L'esportatore funziona DaemonSet su nodi con interfacce di SR-IOV-capable rete ed esporta metriche che possono essere eliminate da Prometheus. Nota Questo componente aggiuntivo richiede nodi con interfacce di rete. SR-IOV-capable | Proprietà | Valore | | --- | --- | | Nome del componente aggiuntivo | `sriov-network-metrics-exporter` | | Namespace | `monitoring` | | Documentazione | [Repo SR-IOV Network Metrics Exporter GitHub ](https://github.com/k8snetworkplumbingwg/sriov-network-metrics-exporter) | | Nome account del servizio | Nessuno | | Policy gestite da IAM | Nessuno | | Autorizzazioni IAM personalizzate | Nessuno | ### AWS Fornitore di driver CSI Secrets Store Il AWS provider del driver CSI Secrets Store è un componente aggiuntivo che consente di recuperare segreti da Secrets Manager AWS e parametri da AWS Systems Manager Parameter Store e montarli come file nei pod Kubernetes. ### Autorizzazioni IAM richieste Il componente aggiuntivo non richiede autorizzazioni IAM. Tuttavia, i pod delle applicazioni richiederanno le autorizzazioni IAM per recuperare i segreti da Secrets Manager e AWS i parametri da AWS Systems Manager Parameter Store. Dopo aver installato il componente aggiuntivo, l'accesso deve essere configurato tramite IAM Roles for Service Accounts (IRSA) o EKS Pod Identity. Per utilizzare IRSA, consulta la documentazione di [configurazione IRSA](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_ascp_irsa.html) di Secrets Manager. Per utilizzare EKS Pod Identity, consulta la [documentazione di configurazione di Secrets Manager Pod Identity](https://docs.aws.amazon.com/secretsmanager/latest/userguide/ascp-pod-identity-integration.html). AWS suggerisce la [politica `AWSSecretsManagerClientReadOnlyAccess` gestita](https://docs.aws.amazon.com/secretsmanager/latest/userguide/reference_available-policies.html#security-iam-awsmanpol-AWSSecretsManagerClientReadOnlyAccess). Per ulteriori informazioni sulle autorizzazioni richieste, consulta `AWSSecretsManagerClientReadOnlyAccess` il AWS Managed Policy Reference. ### Informazioni aggiuntive [Per ulteriori informazioni, consulta il repository secrets-store-csi-driver -provider-awsGitHub .](https://github.com/aws/secrets-store-csi-driver-provider-aws) Per ulteriori informazioni sul componente aggiuntivo, consulta la [documentazione di AWS Secrets Manager relativa al componente aggiuntivo](https://docs.aws.amazon.com/secretsmanager/latest/userguide/ascp-eks-installation.html). ## SageMaker Spazi Amazon Il componente aggiuntivo Amazon SageMaker Spaces offre la possibilità di eseguire notebook IDEs e notebook su cluster EKS o -EKS. HyperPod Gli amministratori possono utilizzare la console EKS per installare il componente aggiuntivo sul proprio cluster e definire configurazioni di spazio predefinite come immagini, risorse di elaborazione, archiviazione locale per le impostazioni dei notebook (storage aggiuntivo da allegare ai rispettivi spazi), file system e script di inizializzazione. Gli sviluppatori di intelligenza artificiale possono utilizzare kubectl per creare, aggiornare ed eliminare spazi. Hanno la flessibilità di utilizzare le configurazioni predefinite fornite dagli amministratori o personalizzare le impostazioni. Gli sviluppatori di intelligenza artificiale possono accedere ai propri spazi su EKS o HyperPod -EKS utilizzando il codice VS locale IDEs, and/or il browser Web che ospita il proprio JupyterLab CodeEditor IDE su un dominio DNS personalizzato configurato dai propri amministratori. Possono anche utilizzare la funzionalità di port forwarding di Kubernetes per accedere agli spazi nei loro browser web. Il nome del componente aggiuntivo di Amazon EKS è `amazon-sagemaker-spaces`. ### Autorizzazioni IAM richieste Questo componente aggiuntivo richiede autorizzazioni IAM. Per ulteriori informazioni sulla configurazione IAM richiesta, consulta [IAM Permissions Setup](https://docs.aws.amazon.com/sagemaker/latest/dg/permission-setup.html) nella Amazon SageMaker Developer Guide. ### Informazioni aggiuntive Per ulteriori informazioni sul componente aggiuntivo e sulle sue funzionalità, consulta [SageMaker AI Notebooks on nella](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-hyperpod-eks-cluster-ide.html) Amazon Developer HyperPod Guide. SageMaker # Componenti aggiuntivi della community Puoi utilizzarlo AWS APIs per installare componenti aggiuntivi della community, come Kubernetes Metrics Server. Puoi scegliere di installare componenti aggiuntivi della community come componenti aggiuntivi di Amazon EKS per ridurre la complessità della manutenzione del software su più cluster. Ad esempio, puoi utilizzare l' AWS API, la CLI o la console di gestione per installare componenti aggiuntivi della community. Puoi installare un componente aggiuntivo della community durante la creazione del cluster. I componenti aggiuntivi della community si gestiscono proprio come i componenti aggiuntivi di Amazon EKS esistenti. I componenti aggiuntivi della community sono diversi dai componenti aggiuntivi esistenti in quanto hanno un ambito di supporto unico. Nota L’utilizzo dei componenti aggiuntivi della community è a discrezione dell’utente. Nell'ambito del [modello di responsabilità condivisa](security.md) tra te e te AWS, ci si aspetta che tu comprenda cosa stai installando nel tuo cluster per questi plug-in di terze parti. Sei anche responsabile dei componenti aggiuntivi della community che soddisfano le sue esigenze di sicurezza del cluster. Per ulteriori informazioni, consulta [Supporto per il software distribuito su EKS](related-projects.md#oss-scope). I componenti aggiuntivi della community non sono creati da. AWS AWS convalida i componenti aggiuntivi della community solo per la compatibilità delle versioni. Ad esempio, se installi un componente aggiuntivo della community su un cluster, AWS verifica se è compatibile con la versione Kubernetes del cluster. È importante sottolineare AWS che non fornisce il supporto completo per i componenti aggiuntivi della community. AWS supporta solo le operazioni del ciclo di vita eseguite utilizzando AWS APIs, ad esempio l'installazione o l'eliminazione di componenti aggiuntivi. Se è necessario supporto per un componente aggiuntivo della community, utilizzare le risorse di progetto esistenti. Ad esempio, è possibile creare un GitHub problema nel repository del progetto. ## Determinare il tipo di componente aggiuntivo Puoi utilizzare la AWS CLI per determinare il tipo di componente aggiuntivo Amazon EKS. Utilizza il seguente comando della CLI per recuperare le informazioni su un componente aggiuntivo. Puoi sostituire `metrics-server` con il nome di qualsiasi componente aggiuntivo. ``` aws eks describe-addon-versions --addon-name metrics-server ``` Esamina l’output della CLI per il campo `owner`. ``` { "addons": [ { "addonName": "metrics-server", "type": "observability", "owner": "community", "addonVersions": [ ``` Se il valore di `owner` è`community`, allora il componente aggiuntivo è un componente aggiuntivo della community. AWS fornisce solo supporto per l'installazione, l'aggiornamento e la rimozione del componente aggiuntivo. Se hai domande sulla funzionalità e sul funzionamento del componente aggiuntivo stesso, utilizza le risorse della community come GitHub Issues. ## Installare o aggiornare il componente aggiuntivo della community Puoi installare o aggiornare i componenti aggiuntivi della community come fai con gli altri componenti aggiuntivi di Amazon EKS. + [Creare un componente aggiuntivo Amazon EKS](creating-an-add-on.md) + [Aggiornamento di un componente aggiuntivo di Amazon EKS](updating-an-add-on.md) + [Rimozione di un componente aggiuntivo Amazon EKS da un cluster](removing-an-add-on.md) ## Componenti aggiuntivi della community disponibili I seguenti componenti aggiuntivi della community sono disponibili presso Amazon EKS. + [Kubernetes Metrics Server](#kubernetes-metrics-server) + [kube-state-metrics](#kube-state-metrics) + [Prometheus Node Exporter](#prometheus-node-exporter) + [Gestione certificati](#addon-cert-manager) + [DNS esterno](#external-dns) + [Fluent Bit](#fluent-bit) ### Kubernetes Metrics Server Il Kubernetes Metrics Server è una fonte scalabile ed efficiente di metriche delle risorse dei container per le pipeline di scalabilità automatica integrate in Kubernetes. Raccoglie le metriche delle risorse da Kubelets e le espone nell’apiserver Kubernetes tramite l’API Metriche per essere utilizzate da Horizontal Pod Autoscaler e Vertical Pod Autoscaler. | Proprietà | Valore | | --- | --- | | Nome del componente aggiuntivo | `metrics-server` | | Namespace | `kube-system` | | Documentazione | [GitHub Readme](https://github.com/kubernetes-sigs/metrics-server) | | Nome account del servizio | Nessuno | | Policy gestite da IAM | Nessuno | | Autorizzazioni IAM personalizzate | Nessuno | ### kube-state-metrics Agente del componente aggiuntivo per generare ed esporre metriche a livello di cluster. Lo stato degli oggetti di Kubernetes nell’API Kubernetes può essere esposto sotto forma di metriche. Un agente aggiuntivo chiamato kube-state-metrics può connettersi al server dell'API Kubernetes ed esporre un endpoint HTTP con metriche generate dallo stato dei singoli oggetti nel cluster. Espone varie informazioni sullo stato degli oggetti come etichette e annotazioni, tempi di startup e terminazione, stato o Passaggio in cui si trova attualmente l’oggetto. | Proprietà | Valore | | --- | --- | | Nome del componente aggiuntivo | `kube-state-metrics` | | Namespace | `kube-state-metrics` | | Documentazione | [Metrics for Kubernetes Object States](https://kubernetes.io/docs/concepts/cluster-administration/kube-state-metrics/) nella documentazione di Kubernetes | | Nome account del servizio | Nessuno | | Policy gestite da IAM | Nessuno | | Autorizzazioni IAM personalizzate | Nessuno | ### Prometheus Node Exporter Esportatore Prometheus per i parametri hardware e del sistema operativo esposti dai kernel \$1NIX, scritto in Go con collettori di metriche collegabili. Prometheus Node Exporter espone un’ampia varietà di metriche relative all’hardware e al kernel. | Proprietà | Valore | | --- | --- | | Nome del componente aggiuntivo | `prometheus-node-exporter` | | Namespace | `prometheus-node-exporter` | | Documentazione | [Monitoring Linux host metrics with the Node Exporter](https://prometheus.io/docs/guides/node-exporter/#monitoring-linux-host-metrics-with-the-node-exporter) nella documentazione di Prometheus | | Nome account del servizio | Nessuno | | Policy gestite da IAM | Nessuno | | Autorizzazioni IAM personalizzate | Nessuno | ### Gestione certificati Gestione certificati può essere utilizzato per gestire la creazione e il rinnovo dei certificati. | Proprietà | Valore | | --- | --- | | Nome del componente aggiuntivo | `cert-manager` | | Namespace | `cert-manager` | | Documentazione | [Cert Manager Docs](https://cert-manager.io/docs/) | | Nome account del servizio | Nessuno | | Policy gestite da IAM | Nessuno | | Autorizzazioni IAM personalizzate | Nessuno | ### DNS esterno Il componente aggiuntivo del DNS esterno di EKS può essere utilizzato per gestire i record DNS di Route53 tramite le risorse di Kubernetes. Le autorizzazioni del DNS esterno possono essere ridotte a `route53:ChangeResourceRecordSets`, `route53:ListHostedZones` e `route53:ListResourceRecordSets` sulle zone ospitate che si desidera gestire. | Proprietà | Valore | | --- | --- | | Nome del componente aggiuntivo | `external-dns` | | Namespace | `external-dns` | | Documentazione | [GitHub Readme](https://github.com/kubernetes-sigs/external-dns) | | Nome account del servizio | `external-dns` | | Policy IAM gestite | ` arn:aws: iam::aws:policy/AmazonRoute53FullAccess` | | Autorizzazioni IAM personalizzate | Nessuno | ### Fluent Bit Fluent Bit è un processore e server d’inoltro di log leggero e ad alte prestazioni. Consente di raccogliere dati data/logs da diverse fonti, unificarli e inviarli a più destinazioni, tra cui Amazon CloudWatch Logs, Amazon S3 e Amazon Kinesis Data Firehose. Fluent Bit è progettato pensando alle prestazioni e all’efficienza delle risorse, il che lo rende ideale per gli ambienti Kubernetes. Questo componente aggiuntivo non richiede autorizzazioni IAM nella configurazione predefinita. Tuttavia, potrebbe essere necessario concedere a questo componente aggiuntivo le autorizzazioni IAM se configuri una posizione di output. AWS Per ulteriori informazioni, consulta [Utilizzo di Pod Identity per assegnare un ruolo IAM a un componente aggiuntivo Amazon EKS](update-addon-role.md). | Proprietà | Valore | | --- | --- | | Nome del componente aggiuntivo | `fluent-bit` | | Namespace | `fluent-bit` | | Documentazione | [Fluent Bit Documentation](https://docs.fluentbit.io/manual/) | | Nome account del servizio | `fluent-bit` | | Policy IAM gestite | Nessuno | | Autorizzazioni IAM personalizzate | Nessuno | ## Visualizzare le attribuzioni Puoi scaricare le attribuzioni open source e le informazioni sulle licenze per i componenti aggiuntivi della community. 1. Determina il nome e la versione del componente aggiuntivo per il quale desideri scaricare le attribuzioni. 1. Aggiorna il seguente comando con il nome e la versione: ``` curl -O https://amazon-eks-docs.s3.amazonaws.com/attributions///attributions.zip ``` Esempio: ``` curl -O https://amazon-eks-docs.s3.amazonaws.com/attributions/kube-state-metrics/v2.14.0-eksbuild.1/attributions.zip ``` 1. Utilizza il comando per scaricare il file. Utilizza questo file zip per visualizzare informazioni sulle attribuzioni delle licenze. # AWS Componenti aggiuntivi del Marketplace Oltre all'elenco precedente di componenti aggiuntivi di Amazon EKS, puoi anche aggiungere un'ampia selezione di componenti software aggiuntivi operativi per Amazon EKS offerti da fornitori di software indipendenti. Scegli un componente aggiuntivo per avere maggiori informazioni sul componente e sui relativi requisiti di installazione. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/IIPj119mspc?rel=0/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/IIPj119mspc?rel=0) ## Accuknox Il nome del componente aggiuntivo è `accuknox_kubearmor` e il namespace è `kubearmor`. Accuknox pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta la sezione [Guida introduttiva KubeArmor](https://docs.kubearmor.io/kubearmor/quick-links/deployment_guide) nella KubeArmor documentazione. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Akuity Il nome del componente aggiuntivo è `akuity_agent` e il namespace è `akuity`. Akuity pubblica il componente aggiuntivo. Per informazioni su come funziona il componente aggiuntivo, consulta [Installazione dell’agente Akuity su Amazon EKS con il componente aggiuntivo Akuity EKS](https://docs.akuity.io/tutorials/eks-addon-agent-install/) nella documentazione della piattaforma Akuity. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Calyptia Il nome del componente aggiuntivo è `calyptia_fluent-bit` e il namespace è `calytia-fluentbit`. Calyptia pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Guida introduttiva all’agente Calyptia Core](https://docs.akuity.io/tutorials/eks-addon-agent-install/) sul sito Web della documentazione di Calyptia. ### Nome account del servizio Il nome dell’account del servizio è `clyptia-fluentbit`. ### AWS politica IAM gestita Questo componente aggiuntivo utilizza la policy gestita da `AWSMarketplaceMeteringRegisterUsage`. Per ulteriori informazioni, consulta [AWSMarketplaceMeteringRegisterUsage](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSMarketplaceMeteringRegisterUsage.html)la AWS Managed Policy Reference Guide. ### Comando per creare il ruolo IAM richiesto Il comando seguente richiede la presenza di un fornitore OpenID Connect (OIDC) di IAM per il cluster. Per stabilire se ne possiedi uno o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). Sostituisci my-cluster con il nome del cluster e my-calyptia-role con il nome del ruolo. Questo comando richiede che [eksctl](https://eksctl.io) sia installato sul tuo dispositivo. Se devi utilizzare uno strumento diverso per creare il ruolo e prendere nota dell’account di servizio Kubernetes, consulta [Assegnare ruoli IAM agli account di servizio Kubernetes](associate-service-account-role.md). ``` eksctl create iamserviceaccount --name service-account-name --namespace calyptia-fluentbit --cluster my-cluster --role-name my-calyptia-role \ --role-only --attach-policy-arn arn:aws: iam::aws:policy/AWSMarketplaceMeteringRegisterUsage --approve ``` ## Observability Collector di Cisco Il nome del componente aggiuntivo è `cisco_cisco-cloud-observability-collectors` e il namespace è `appdynamics`. Cisco pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Use the Cisco Cloud Observability AWS Marketplace](https://docs.appdynamics.com/observability/cisco-cloud-observability/en/kubernetes-and-app-service-monitoring/install-kubernetes-and-app-service-monitoring-with-amazon-elastic-kubernetes-service/use-the-cisco-cloud-observability-aws-marketplace-add-ons) Add-Ons nella documentazione Cisco. AppDynamics ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Cisco Observability Operator Il nome del componente aggiuntivo è `cisco_cisco-cloud-observability-operators` e il namespace è `appdynamics`. Cisco pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Use the Cisco Cloud Observability AWS Marketplace](https://docs.appdynamics.com/observability/cisco-cloud-observability/en/kubernetes-and-app-service-monitoring/install-kubernetes-and-app-service-monitoring-with-amazon-elastic-kubernetes-service/use-the-cisco-cloud-observability-aws-marketplace-add-ons) Add-Ons nella documentazione Cisco. AppDynamics ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## CLOUDSOFT Il nome del componente aggiuntivo è `cloudsoft_cloudsoft-amp` e il namespace è `cloudsoft-amp`. CLOUDSOFT pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Componente aggiuntivo di Amazon EKS](https://docs.cloudsoft.io/operations/configuration/aws-eks-addon.html) nella documentazione CLOUDSOFT. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Cribl Il nome del componente aggiuntivo è `cribl_cribledge` e il namespace è `cribledge`. Cribl pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Installazione del componente aggiuntivo Cribl di Amazon EKS per Edge](https://docs.cribl.io/edge/usecase-edge-aws-eks/) nella documentazione di Cribl ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Dynatrace Il nome del componente aggiuntivo è `dynatrace_dynatrace-operator` e il namespace è `dynatrace`. Dynatrace pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Monitoraggio di Kubernetes](https://www.dynatrace.com/technologies/kubernetes-monitoring/) nella documentazione di Dynatrace. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Datree Il nome del componente aggiuntivo è `datree_engine-pro` e il namespace è `datree`. Datree pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Integrazione di Amazon EKS](https://hub.datree.io/integrations/eks-integration) nella documentazione Datree. ### Nome account del servizio Il nome dell'account del servizio è datree-webhook-server-awsmp. ### AWS politica IAM gestita La politica gestita è AWSLicenseManagerConsumptionPolicy. Per ulteriori informazioni, consulta [AWSLicenseManagerConsumptionPolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLicenseManagerConsumptionPolicy.html)la AWS Managed Policy Reference Guide. ### Comando per creare il ruolo IAM richiesto Il comando seguente richiede la presenza di un fornitore OpenID Connect (OIDC) di IAM per il cluster. Per stabilire se ne possiedi uno o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). Sostituisci my-cluster con il nome del cluster e my-datree-role con il nome del ruolo. Questo comando richiede che [eksctl](https://eksctl.io) sia installato sul tuo dispositivo. Se devi utilizzare uno strumento diverso per creare il ruolo e prendere nota dell’account di servizio Kubernetes, consulta [Assegnare ruoli IAM agli account di servizio Kubernetes](associate-service-account-role.md). ``` eksctl create iamserviceaccount --name datree-webhook-server-awsmp --namespace datree --cluster my-cluster --role-name my-datree-role \ --role-only --attach-policy-arn arn:aws: iam::aws:policy/service-role/AWSLicenseManagerConsumptionPolicy --approve ``` ### Autorizzazioni personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Datadog Il nome del componente aggiuntivo è `datadog_operator` e il namespace è `datadog-agent`. Datadog pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Installazione dell’agente Datadog su Amazon EKS con il componente aggiuntivo Datadog Operator](https://docs.datadoghq.com/containers/guide/operator-eks-addon/?tab=console) nella documentazione di Datadog. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Groundcover Il nome del componente aggiuntivo è `groundcover_agent` e il namespace è`groundcover`. Groundcover pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Installazione del componente aggiuntivo Groundcover di Amazon EKS](https://docs.groundcover.com/docs/~/changes/VhDDAl1gy1VIO3RIcgxD/configuration/customization-guide/customize-deployment/eks-add-on) nella documentazione di Groundcover. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## IBM Instana Il nome del componente aggiuntivo è `instana-agent` e il namespace è `instana-agent`. IBM pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Implementazione dell'osservabilità per i carichi di lavoro Amazon EKS utilizzando il componente aggiuntivo Amazon EKS di Instana](https://aws.amazon.com/blogs/ibm-redhat/implement-observability-for-amazon-eks-workloads-using-the-instana-amazon-eks-add-on/) [e Monitoraggio e ottimizzazione dei costi di Amazon EKS con IBM Instana](https://aws.amazon.com/blogs/ibm-redhat/monitor-and-optimize-amazon-eks-costs-with-ibm-instana-and-kubecost/) e Kubecost nel blog. AWS Instana Observability (Instana) offre un componente aggiuntivo Amazon EKS che implementa agenti Instana nei cluster Amazon EKS. I clienti possono utilizzare questo componente aggiuntivo per raccogliere e analizzare dati sulle prestazioni in tempo reale per ottenere approfondimenti sulle loro applicazioni containerizzate. Il componente aggiuntivo Instana Amazon EKS offre visibilità su tutti gli ambienti Kubernetes. Una volta distribuito, l’agente Instana rileva automaticamente i componenti all’interno dei cluster Amazon EKS, inclusi nodi, namespace, implementazioni, servizi e pod. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Grafana Labs Il nome del componente aggiuntivo è `grafana-labs_kubernetes-monitoring` e il namespace è `monitoring`. Grafana Labs pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Configura il monitoraggio di Kubernetes come componente aggiuntivo con Amazon EKS](https://grafana.com/docs/grafana-cloud/monitor-infrastructure/kubernetes-monitoring/configuration/config-aws-eks/) nella documentazione di Grafana Labs. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Guance + Publisher: GUANCE + Nome: `guance_datakit` + Namespace: `datakit` + Nome account di servizio: con questo componente aggiuntivo non è utilizzato un account di servizio. + Policy IAM gestita da AWS : con questo componente aggiuntivo non è utilizzata una policy gestita. + Autorizzazioni IAM personalizzate: con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. + Istruzioni di configurazione e utilizzo: consulta [Using Amazon EKS add-on](https://docs.guance.com/en/datakit/datakit-eks-deploy/#add-on-install) nella documentazione di Guance. ## Proxy HA Il nome è `haproxy-technologies_kubernetes-ingress-ee` e il namespace è `haproxy-controller`. HA Proxy pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Integrazione di Amazon EKS](https://hub.datree.io/integrations/eks-integration) nella documentazione Datree. ### Nome account del servizio Il nome dell’account del servizio è `customer defined`. ### AWS politica IAM gestita La politica gestita è AWSLicenseManagerConsumptionPolicy. Per ulteriori informazioni, consulta [AWSLicenseManagerConsumptionPolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLicenseManagerConsumptionPolicy.html)la AWS Managed Policy Reference Guide. ### Comando per creare il ruolo IAM richiesto Il comando seguente richiede la presenza di un fornitore OpenID Connect (OIDC) di IAM per il cluster. Per stabilire se ne possiedi uno o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). Sostituisci my-cluster con il nome del cluster e my-haproxy-role con il nome del ruolo. Questo comando richiede che [eksctl](https://eksctl.io) sia installato sul tuo dispositivo. Se devi utilizzare uno strumento diverso per creare il ruolo e prendere nota dell’account di servizio Kubernetes, consulta [Assegnare ruoli IAM agli account di servizio Kubernetes](associate-service-account-role.md). ``` eksctl create iamserviceaccount --name service-account-name --namespace haproxy-controller --cluster my-cluster --role-name my-haproxy-role \ --role-only --attach-policy-arn arn:aws: iam::aws:policy/service-role/AWSLicenseManagerConsumptionPolicy --approve ``` ### Autorizzazioni personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Kpow Il nome del componente aggiuntivo è `factorhouse_kpow` e il namespace è `factorhouse`. Factorhouse pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [AWS Marketplace LM](https://docs.kpow.io/installation/aws-marketplace-lm/) nella documentazione di Kpow. ### Nome account del servizio Il nome dell’account del servizio è `kpow`. ### AWS politica IAM gestita La politica gestita è AWSLicenseManagerConsumptionPolicy. Per ulteriori informazioni, consulta [AWSLicenseManagerConsumptionPolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLicenseManagerConsumptionPolicy.html)la AWS Managed Policy Reference Guide. ### Comando per creare il ruolo IAM richiesto Il comando seguente richiede la presenza di un fornitore OpenID Connect (OIDC) di IAM per il cluster. Per stabilire se ne possiedi uno o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). Sostituisci my-cluster con il nome del cluster e my-kpow-role con il nome del ruolo. Questo comando richiede che [eksctl](https://eksctl.io) sia installato sul tuo dispositivo. Se devi utilizzare uno strumento diverso per creare il ruolo e prendere nota dell’account di servizio Kubernetes, consulta [Assegnare ruoli IAM agli account di servizio Kubernetes](associate-service-account-role.md). ``` eksctl create iamserviceaccount --name kpow --namespace factorhouse --cluster my-cluster --role-name my-kpow-role \ --role-only --attach-policy-arn arn:aws: iam::aws:policy/service-role/AWSLicenseManagerConsumptionPolicy --approve ``` ### Autorizzazioni personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Kubecost Il nome del componente aggiuntivo è `kubecost_kubecost` e il namespace è `kubecost`. Kubecost pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Integrazione di AWS Cloud Billing](https://docs.kubecost.com/install-and-configure/install/cloud-integration/aws-cloud-integrations) nella documentazione di Kubecost. Nel tuo cluster deve essere installato [Archivia volumi Kubernetes con Amazon EBS](ebs-csi.md), altrimenti comparirà un messaggio di errore. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Kasten Il nome del componente aggiuntivo è `kasten_k10` e il namespace è `kasten-io`. Kasten by Veeam pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Installazione di K10 sull'utilizzo del componente aggiuntivo AWS Amazon EKS](https://docs.kasten.io/latest/install/aws-eks-addon/aws-eks-addon.html) nella documentazione di Kasten. È necessario che il driver CSI di Amazon EBS sia installato nel cluster `StorageClass` predefinito. ### Nome account del servizio Il nome dell’account del servizio è `k10-k10`. ### AWS politica IAM gestita La politica gestita è AWSLicenseManagerConsumptionPolicy. Per ulteriori informazioni, consulta [AWSLicenseManagerConsumptionPolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLicenseManagerConsumptionPolicy.html)la AWS Managed Policy Reference Guide. ### Comando per creare il ruolo IAM richiesto Il comando seguente richiede la presenza di un fornitore OpenID Connect (OIDC) di IAM per il cluster. Per stabilire se ne possiedi uno o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). Sostituisci my-cluster con il nome del cluster e my-kasten-role con il nome del ruolo. Questo comando richiede che [eksctl](https://eksctl.io) sia installato sul tuo dispositivo. Se devi utilizzare uno strumento diverso per creare il ruolo e prendere nota dell’account di servizio Kubernetes, consulta [Assegnare ruoli IAM agli account di servizio Kubernetes](associate-service-account-role.md). ``` eksctl create iamserviceaccount --name k10-k10 --namespace kasten-io --cluster my-cluster --role-name my-kasten-role \ --role-only --attach-policy-arn arn:aws: iam::aws:policy/service-role/AWSLicenseManagerConsumptionPolicy --approve ``` ### Autorizzazioni personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Kong Il nome del componente aggiuntivo è `kong_konnect-ri` e il namespace è `kong`. Kong pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Installazione del componente aggiuntivo Kong Gateway di EKS](https://kong.github.io/aws-marketplace-addon-kong-gateway/) nella documentazione di Kong. Nel tuo cluster deve essere installato [Archivia volumi Kubernetes con Amazon EBS](ebs-csi.md), altrimenti comparirà un messaggio di errore. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## LeakSignal Il nome del componente aggiuntivo è `leaksignal_leakagent` e il namespace è. `leakagent` LeakSignal pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, vedere https://www.leaksignal.com/docs/ LeakAgent /Deployment/AWS%20Eks%20Addon/ [Installare il componente aggiuntivo] nella documentazione LeakAgent LeakSignal Nel tuo cluster deve essere installato [Archivia volumi Kubernetes con Amazon EBS](ebs-csi.md), altrimenti comparirà un messaggio di errore. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## NetApp Il nome del componente aggiuntivo è `netapp_trident-operator` e il namespace è. `trident` NetApp pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Configurare il componente aggiuntivo Trident EKS](https://docs.netapp.com/us-en/trident/trident-use/trident-aws-addon.html) nella documentazione. NetApp ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## New Relic Il nome del componente aggiuntivo è `new-relic_kubernetes-operator` e il namespace è `newrelic`. New Relic pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Installazione del componente aggiuntivo New Relic per EKS](https://docs.newrelic.com/docs/infrastructure/amazon-integrations/connect/eks-add-on) nella documentazione di New Relic. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Rafay Il nome del componente aggiuntivo è `rafay-systems_rafay-operator` e il namespace è `rafay-system`. Rafay pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Installazione del componente aggiuntivo Rafay di Amazon EKS](https://docs.rafay.co/clusters/import/eksaddon/) nella documentazione di Rafay. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Rad Security + Editore: RAD SECURITY + Nome: `rad-security_rad-security` + Namespace: `ksoc` + Nome account di servizio: con questo componente aggiuntivo non è utilizzato un account di servizio. + Policy IAM gestita da AWS : con questo componente aggiuntivo non è utilizzata una policy gestita. + Autorizzazioni IAM personalizzate: con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. + Istruzioni di configurazione e utilizzo: vedi [Installazione di Rad tramite The AWS Marketplace](https://docs.rad.security/docs/installing-ksoc-in-the-aws-marketplace) nella documentazione di Rad Security. ## SolarWinds + Publisher: SOLARWINDS + Nome: `solarwinds_swo-k8s-collector-addon` + Namespace: `solarwinds` + Nome account di servizio: con questo componente aggiuntivo non è utilizzato un account di servizio. + Policy IAM gestita da AWS : con questo componente aggiuntivo non è utilizzata una policy gestita. + Autorizzazioni IAM personalizzate: con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. + Istruzioni di configurazione e utilizzo: consulta [Monitorare un cluster Amazon EKS](https://documentation.solarwinds.com/en/success_center/observability/content/configure/configure-kubernetes.htm#MonitorAmazonEKS) nella SolarWinds documentazione. ## Solo Il nome del componente aggiuntivo è `solo-io_istio-distro` e il namespace è `istio-system`. Solo pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Installazione di Istio](https://docs.solo.io/gloo-mesh-enterprise/main/setup/install/eks_addon/) nella documentazione di Solo.io. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Snyk + Publisher: SNYK + Nome: `snyk_runtime-sensor` + Namespace: `snyk_runtime-sensor` + Nome account di servizio: con questo componente aggiuntivo non è utilizzato un account di servizio. + Policy IAM gestita da AWS : con questo componente aggiuntivo non è utilizzata una policy gestita. + Autorizzazioni IAM personalizzate: con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. + Istruzioni di configurazione e utilizzo: consulta [Sensore di runtime Snyk](https://docs.snyk.io/integrate-with-snyk/snyk-runtime-sensor) nei documenti per gli utenti di Snyk. ## Stormforge Il nome del componente aggiuntivo è `stormforge_optimize-Live` e il namespace è `stormforge-system`. Stormforge pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Installazione dell' StormForge agente](https://docs.stormforge.io/optimize-live/getting-started/install-v2/) nella StormForge documentazione. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## SUSE + Publisher: SUSE + Nome: `suse_observability-agent` + Namespace: `suse-observability` + Nome account di servizio: con questo componente aggiuntivo non è utilizzato un account di servizio. + Policy IAM gestita da AWS : con questo componente aggiuntivo non è utilizzata una policy gestita. + Autorizzazioni IAM personalizzate: con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. + Istruzioni per la configurazione e l’uso: consulta [Avvio rapido](https://docs.stackstate.com/get-started/k8s-quick-start-guide#amazon-eks) nella documentazione di SUSE. ## Splunk Il nome del componente aggiuntivo è `splunk_splunk-otel-collector-chart` e il namespace è `splunk-monitoring`. Splunk pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Installa il componente aggiuntivo di Splunk per Amazon EKS](https://help.splunk.com/en/splunk-observability-cloud/manage-data/splunk-distribution-of-the-opentelemetry-collector/get-started-with-the-splunk-distribution-of-the-opentelemetry-collector/collector-for-kubernetes/kubernetes-eks-add-on) nella documentazione di Splunk. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Teleport Il nome del componente aggiuntivo è `teleport_teleport` e il namespace è `teleport`. Teleport pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Come funziona Teleport](https://goteleport.com/how-it-works/) nella documentazione di Teleport. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Tetrate Il nome del componente aggiuntivo è `tetrate-io_istio-distro` e il namespace è `istio-system`. Tetrate Io pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta il sito Web [Tetrate Istio Distro](https://tetratelabs.io/). ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Upbound Universal Crossplane Il nome del componente aggiuntivo è `upbound_universal-crossplane` e il namespace è `upbound-system`. Upbound pubblica il componente aggiuntivo. Per informazioni sul componente aggiuntivo, consulta [Upbound Universal Crossplane (UXP)](https://docs.upbound.io/uxp/) nella documentazione di Upbound. ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. ## Upwind Il nome del componente aggiuntivo è `upwind` e il namespace è `upwind`. Upwind pubblica il componente aggiuntivo. Per ulteriori informazioni sul componente aggiuntivo, consulta [Documentazione di Upwind](https://docs.upwind.io/install-sensor/kubernetes/install?installation-method=amazon-eks-addon). ### Nome account del servizio Con questo componente aggiuntivo non è utilizzato un account di servizio. ### AWS politica IAM gestita Con questo componente aggiuntivo non è utilizzata una policy gestita. ### Autorizzazioni IAM personalizzate Con questo componente aggiuntivo non sono utilizzate autorizzazioni personalizzate. # Creare un componente aggiuntivo Amazon EKS I componenti aggiuntivi Amazon EKS sono software aggiuntivi per cluster Amazon EKS. Tutti i componenti aggiuntivi di Amazon EKS: + Includono le patch di sicurezza e le correzioni dei bug più recenti. + Sono convalidati AWS per funzionare con Amazon EKS. + Riducono la quantità di lavoro necessaria per gestire il software del componente aggiuntivo. Puoi creare un componente aggiuntivo Amazon EKS utilizzando `eksctl` Console di gestione AWS, o la AWS CLI. Se il componente aggiuntivo richiede un ruolo IAM, consultare i dettagli del componente aggiuntivo specifico alla pagina [Amazon EKS add-ons](eks-add-ons.md) per conoscere i dettagli sulla creazione del ruolo. ## Prerequisiti Completare le seguenti operazioni prima di creare un componente aggiuntivo: + Il cluster deve esistere prima di poter creare un componente aggiuntivo. Per ulteriori informazioni, consulta [Crea un cluster Amazon EKS.](create-cluster.md). + Verificare se il componente aggiuntivo richiede un ruolo IAM. Per ulteriori informazioni, consulta [Verifica la compatibilità delle versioni aggiuntive di Amazon EKS con un cluster](addon-compat.md). + Verificare che la versione del componente aggiuntivo Amazon EKS sia compatibile con il cluster. Per ulteriori informazioni, consulta [Verifica la compatibilità delle versioni aggiuntive di Amazon EKS con un cluster](addon-compat.md). + Verifica che la versione 0.190.0 o successiva dello strumento da riga di `eksctl` comando sia installata sul tuo computer o. AWS CloudShell Per ulteriori informazioni, vedere [Installazione](https://eksctl.io/installation/) sul sito Web `eksctl`. ## Procedura Puoi creare un componente aggiuntivo Amazon EKS utilizzando `eksctl` Console di gestione AWS, o la AWS CLI. Se il componente aggiuntivo richiede un ruolo IAM, consultare i dettagli del componente aggiuntivo specifico alla pagina [Available Amazon EKS add-ons from AWS](workloads-add-ons-available-eks.md) per conoscere i dettagli sulla creazione del ruolo. ## Creare un componente aggiuntivo (eksctl) 1. Visualizza i nomi dei componenti aggiuntivi disponibili per una versione del cluster. Sostituisci 1.35 con la versione del cluster. ``` eksctl utils describe-addon-versions --kubernetes-version 1.35 | grep AddonName ``` Di seguito viene riportato un output di esempio: ``` "AddonName": "aws-ebs-csi-driver", "AddonName": "coredns", "AddonName": "kube-proxy", "AddonName": "vpc-cni", "AddonName": "adot", "AddonName": "dynatrace_dynatrace-operator", "AddonName": "upbound_universal-crossplane", "AddonName": "teleport_teleport", "AddonName": "factorhouse_kpow", [...] ``` 1. Visualizza le versioni disponibili per il componente aggiuntivo da creare. Sostituisci 1.35 con la versione del cluster. Sostituisci name-of-addon con il nome del componente aggiuntivo di cui visualizzare le versioni. Il nome deve essere uno di quelli restituiti al passaggio precedente. ``` eksctl utils describe-addon-versions --kubernetes-version 1.35 --name name-of-addon | grep AddonVersion ``` L'output seguente è un esempio di ciò che viene restituito per il componente aggiuntivo denominato `vpc-cni`. Come vedi, il componente aggiuntivo ha diverse versioni disponibili. ``` "AddonVersions": [ "AddonVersion": "v1.12.0-eksbuild.1", "AddonVersion": "v1.11.4-eksbuild.1", "AddonVersion": "v1.10.4-eksbuild.1", "AddonVersion": "v1.9.3-eksbuild.1", ``` 1. Determina se il componente aggiuntivo che desideri creare è un componente aggiuntivo Amazon EKS o AWS Marketplace. Il AWS Marketplace offre componenti aggiuntivi di terze parti che richiedono il completamento di passaggi aggiuntivi per creare il componente aggiuntivo. ``` eksctl utils describe-addon-versions --kubernetes-version 1.35 --name name-of-addon | grep ProductUrl ``` Se non viene restituito alcun output, il componente aggiuntivo è Amazon EKS. Se viene restituito un output, il componente aggiuntivo è un componente aggiuntivo AWS Marketplace. Il seguente output viene fornito per un componente aggiuntivo denominato `teleport_teleport`. ``` "ProductUrl": "https://aws.amazon.com/marketplace/pp?sku=3bda70bb-566f-4976-806c-f96faef18b26" ``` Puoi trovare ulteriori informazioni sul componente aggiuntivo nel AWS Marketplace con l'URL restituito. Se il componente aggiuntivo richiede un abbonamento, puoi abbonarti al componente aggiuntivo tramite Marketplace AWS . Se intendi creare un componente aggiuntivo dal AWS Marketplace, il [responsabile IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal) che stai utilizzando per creare il componente aggiuntivo deve avere l'autorizzazione per creare il ruolo collegato al [AWSServiceRoleForAWSLicenseManagerRole](https://docs.aws.amazon.com/license-manager/latest/userguide/license-manager-role-core.html)servizio. Per ulteriori informazioni sull'assegnazione di autorizzazioni a un'entità IAM, consulta [Aggiunta e rimozione di autorizzazioni per identità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella Guida per l'utente di IAM. 1. Crea un componente aggiuntivo di Amazon EKS. Copia il comando e sostituiscilo come segue: user-data + Sostituisci my-cluster con il nome del cluster. + Sostituisci name-of-addon con il nome del componente aggiuntivo da creare. + Se desideri una versione del componente aggiuntivo precedente all'ultima versione, sostituiscila latest con il numero di versione restituito nell'output di un passaggio precedente che desideri utilizzare. + Se il componente aggiuntivo utilizza un ruolo dell'account di servizio, sostituisci 111122223333 con l'ID dell'account e sostituisci role-name con il nome del ruolo. Per istruzioni sulla creazione di un ruolo per l’account di servizio, consultare la documentazione del componente aggiuntivo da creare. Per un elenco dei componenti aggiuntivi, consultare la pagina [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). Per specificare un ruolo per l’account di servizio è necessario disporre di un gestore OpenID Connect (OIDC) IAM per il cluster. Per stabilire se ne possiedi uno per il tuo cluster o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). Se il componente aggiuntivo non utilizza un ruolo per l’account di servizio, eliminare `--service-account-role-arn arn:aws: iam::111122223333:role/role-name`. + Questo comando di esempio sovrascrive la configurazione di qualunque versione autogestita esistente del componente aggiuntivo, se presente. Se non desideri sovrascrivere la configurazione di un componente aggiuntivo autogestito esistente, rimuovi l'opzione. --force Se rimuovi l'opzione e il componente aggiuntivo di Amazon EKS deve sovrascrivere la configurazione di un componente aggiuntivo autogestito esistente, la creazione del componente aggiuntivo di Amazon EKS non riesce e viene visualizzato un messaggio di errore per semplificare la soluzione del conflitto. Prima di specificare questa opzione, assicurarsi che il componente aggiuntivo Amazon EKS non gestisca le impostazioni da gestire autonomamente, perché questa opzione le sovrascrive. ``` eksctl create addon --cluster my-cluster --name name-of-addon --version latest \ --service-account-role-arn arn:aws: iam::111122223333:role/role-name --force ``` Puoi vedere un elenco completo di tutte opzioni disponibili per il comando. ``` eksctl create addon --help ``` Per ulteriori informazioni sulle opzioni disponibili, consulta [Componenti aggiuntivi](https://eksctl.io/usage/addons/) nella documentazione di `eksctl`. ## Crea componente aggiuntivo (console)AWS 1. Aprire la [Console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters). 1. Nel pannello di navigazione a sinistra, seleziona Cluster. 1. Scegliere il nome del cluster per cui si desidera creare il componente aggiuntivo. 1. Selezionare la scheda Componenti aggiuntivi. 1. Scegli Ottieni altri componenti aggiuntivi. 1. Nella pagina Select add-ons (Seleziona componenti aggiuntivi), scegli i componenti aggiuntivi da aggiungere al tuo cluster. Puoi aggiungere tutti i componenti aggiuntivi Amazon EKS e i componenti aggiuntivi AWS Marketplace di cui hai bisogno. Per i componenti aggiuntivi di AWS Marketplace, il [responsabile IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal) che stai utilizzando per creare il componente aggiuntivo deve disporre delle autorizzazioni per leggere i diritti per il componente aggiuntivo da. AWS LicenseManager AWS LicenseManager richiede un ruolo [AWSServiceRoleForAWSLicenseManagerRole](https://docs.aws.amazon.com/license-manager/latest/userguide/license-manager-role-core.html)collegato al servizio (SLR) che consente alle risorse di gestire le licenze per tuo conto. AWS L’SLR è un requisito una tantum per singolo account e non sarà necessario creare SLR separati per ciascun componente aggiuntivo o per ciascun cluster. Per ulteriori informazioni sull'assegnazione di autorizzazioni a un [principale IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal), consulta [Aggiunta e rimozione di autorizzazioni per identità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella Guida per l'utente di IAM. Se i componenti aggiuntivi del AWS Marketplace che desideri installare non sono elencati, puoi fare clic sulla numerazione delle pagine per visualizzare altri risultati di pagina o effettuare una ricerca nella casella di ricerca. Nelle Opzioni di filtro, puoi eseguire una ricerca anche per categoria, fornitore o modello di prezzi e quindi scegliere i componenti aggiuntivi dai risultati della ricerca. Dopo aver selezionato i componenti aggiuntivi da installare, scegliere Avanti. 1. Nella pagina Configura le impostazioni dei componenti aggiuntivi selezionati, procedi come segue: 1. Scegli Visualizza le opzioni di abbonamento per aprire il modulo delle opzioni di abbonamento. Consulta le sezioni Dettagli sui prezzi e Note legali, quindi scegli il pulsante Abbonati per continuare. 1. Per Versione, selezionare la versione da installare. È preferibile la versione contrassegnata come latest, a meno che il singolo componente aggiuntivo da creare non consigli una versione differente. Per determinare se un componente aggiuntivo ha una versione consigliata, consultare la documentazione del componente aggiuntivo da creare. Per un elenco dei componenti aggiuntivi, consultare la pagina [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). 1. Sono disponibili due opzioni per configurare i ruoli per i componenti aggiuntivi: il ruolo IAM di EKS Pod Identity e i ruoli IAM per gli account di servizio (IRSA). Seguire la procedura adeguata di seguito per l’opzione preferita. Se tutti i componenti aggiuntivi selezionati includono Richiede un abbonamento in Stato, scegliere Avanti. Non è possibile procedere con la [configurazione di questi componenti aggiuntivi](updating-an-add-on.md) finché non sarà stato sottoscritto l’abbonamento dopo la creazione del cluster. Per i componenti aggiuntivi che non includono Richiede un abbonamento in Stato: 1. Per il ruolo IAM di Pod Identity per l’account di servizio, è possibile utilizzare un ruolo IAM di EKS Pod Identity esistente o crearne uno con il pulsante Crea ruolo consigliato. Questo campo indicherà solo le opzioni con la policy di attendibilità adeguata. Se non esiste alcun ruolo da selezionare, non si dispone di un ruolo esistente con una policy di attendibilità corrispondente. Per configurare un ruolo IAM di EKS Pod Identity per gli account di servizio del componente aggiuntivo selezionato, scegliere Crea ruolo consigliato. La procedura guidata per la creazione dei ruoli si apre in una finestra separata. La procedura guidata compilerà automaticamente le informazioni sul ruolo come indicato di seguito. Per ogni componente aggiuntivo in cui si desidera creare il ruolo IAM di EKS Pod Identity, completare i passaggi della procedura guidata IAM come indicato di seguito. + Nel passaggio Seleziona un'entità affidabile, l'opzione di AWS servizio per EKS e lo use case per EKS - Pod Identity sono preselezionate e la politica di attendibilità appropriata verrà compilata automaticamente per il componente aggiuntivo. Ad esempio, il ruolo verrà creato con la policy di attendibilità adeguata contenente il principale IAM pods.eks.amazonaws.com, come descritto nella pagina [Vantaggi delle associazioni EKS Pod Identity](pod-identities.md#pod-id-benefits). Scegli Next (Successivo). + Al passaggio Aggiungi autorizzazioni, viene preselezionata la policy gestita adeguata per la policy del ruolo per il componente aggiuntivo. Ad esempio, per il componente aggiuntivo CNI di Amazon VPC, il ruolo verrà creato con la policy gestita `AmazonEKS_CNI_Policy`, come descritto nella pagina [Plug-in della CNI di Amazon VPC per Kubernetes](workloads-add-ons-available-eks.md#add-ons-vpc-cni). Scegli Next (Successivo). + Al passaggio Nomina, verifica e crea, in Nome del ruolo, viene inserito automaticamente il nome del ruolo predefinito per il componente aggiuntivo. Ad esempio, per il componente aggiuntivo Amazon VPC CNI, il ruolo verrà creato con il nome Amazon. EKSPod IdentityAmazon VPCCNIRole In Descrizione, la descrizione predefinita viene compilata automaticamente con la descrizione adeguata per il componente aggiuntivo. Ad esempio, per il componente aggiuntivo Amazon VPC CNI, il ruolo verrà creato con la descrizione Permette ai pod in esecuzione nel cluster Amazon EKS di accedere alle risorse. AWS In Policy di attendibilità, viene visualizzata la policy di attendibilità compilata per il componente aggiuntivo. Scegli Crea ruolo. NOTA: mantenere il nome del ruolo predefinito consente a EKS di preselezionare il ruolo dei componenti aggiuntivi nei nuovi cluster o quando si aggiungono componenti aggiuntivi ai cluster esistenti. È comunque possibile sostituire tale nome e il ruolo sarà disponibile per il componente aggiuntivo in tutti i cluster, ma dovrà essere selezionato manualmente dal menu a discesa. 1. Per i componenti aggiuntivi che non includono Richiede un abbonamento in Stato e per i quali si desidera configurare i ruoli utilizzando IRSA, consultare la documentazione relativa al componente aggiuntivo da creare per definire una policy IAM e collegarla a un ruolo. Per un elenco dei componenti aggiuntivi, consultare la pagina [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). Per selezionare un ruolo IAM è necessario disporre di un gestore OpenID Connect (OIDC) IAM per il cluster. Per stabilire se ne possiedi uno per il tuo cluster o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). 1. Scegli Optional configuration settings (Impostazioni di configurazione facoltative). 1. Se il componente aggiuntivo richiede una configurazione, inseriscila nella casella Configuration values (Valori di configurazione). Per determinare se il componente aggiuntivo richiede informazioni di configurazione, consultare la documentazione del componente aggiuntivo da creare. Per un elenco dei componenti aggiuntivi, consultare la pagina [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). 1. Selezionare una delle opzioni disponibili per Metodo di risoluzione dei conflitti. Se si sceglie Sostituisci come Metodo di risoluzione dei conflitti, una o più impostazioni per il componente aggiuntivo esistente possono essere sovrascritte con le impostazioni del componente aggiuntivo Amazon EKS. Se non si abilita questa opzione e c’è un conflitto con le impostazioni esistenti, l’operazione non va a buon fine e viene visualizzato un messaggio di errore per aiutarti a risolvere il conflitto. Prima di scegliere questa opzione, assicurarsi che il componente aggiuntivo Amazon EKS non gestisca le impostazioni che devono essere autogestite. 1. Se si desidera installare il componente aggiuntivo in un namespace specifico, inserirlo nel campo Namespace. Per AWS i componenti aggiuntivi della community, puoi definire uno spazio dei nomi Kubernetes personalizzato in cui installare il componente aggiuntivo. Per ulteriori informazioni, consulta [Namespace personalizzato per componenti aggiuntivi](eks-add-ons.md#custom-namespace). 1. Scegli Next (Successivo). 1. Nella pagina Rivedi e aggiungi, scegli Crea. Una volta completata l'installazione del componente aggiuntivo, vengono visualizzati i componenti aggiuntivi installati. 1. Se uno dei componenti aggiuntivi installati richiede una sottoscrizione, completa la procedura seguente: 1. scegli il pulsante Subscribe (Sottoscrivi) nell'angolo inferiore destro del componente aggiuntivo. Verrai indirizzato alla pagina del componente aggiuntivo nel AWS Marketplace. Leggi le informazioni sul componente aggiuntivo, ad esempio Product Overview (Panoramica del prodotto) e Pricing information (Informazioni sui prezzi). 1. Seleziona il pulsante Continue to Subscribe (Continua la sottoscrizione) nella parte superiore destra della pagina del componente aggiuntivo. 1. Leggi i Terms and Conditions (Termini e condizioni). Se li accetti, scegli Accept Terms (Accetta i termini). L'elaborazione della sottoscrizione può richiedere vari minuti. Durante l'elaborazione della sottoscrizione, il pulsante Return to Amazon EKS Console (Torna alla console Amazon EKS) è disattivato. 1. Al termine dell'elaborazione dell'abbonamento, il pulsante Return to Amazon EKS Console (Torna alla console Amazon EKS) non è più disattivato. Scegli il pulsante per tornare alla scheda Add-ons (Componenti aggiuntivi) della console Amazon EKS per il tuo cluster. 1. Per il componente aggiuntivo che hai sottoscritto, scegli Remove and reinstall (Rimuovi e reinstalla), quindi scegli Reinstall add-on (Reinstalla componente aggiuntivo). L'installazione del componente aggiuntivo può richiedere vari minuti. Una volta completata l'installazione, puoi configurare il componente aggiuntivo. ## Crea componente aggiuntivo (AWS CLI) 1. È necessaria la versione `2.12.3` o una versione successiva `1.27.160` o una versione o successiva dell'interfaccia a riga di AWS comando (AWS CLI) installata e configurata sul dispositivo o. AWS CloudShell Per verificare la versione attuale, usa `aws --version | cut -d / -f2 | cut -d ' ' -f1`. I gestori di pacchetti come `yum` Homebrew per macOS sono spesso diverse versioni dell'ultima versione della CLI AWS . `apt-get` Per installare la versione più recente, consulta [Installazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [configurazione rapida con aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) nella Guida per l'utente dell'interfaccia a riga di AWS comando. La versione AWS CLI installata in AWS CloudShell potrebbe anche contenere diverse versioni precedenti alla versione più recente. Per aggiornarlo, consulta [Installazione della AWS CLI nella tua home directory nella Guida per](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) l'* AWS CloudShell utente. 1. Determina quali componenti aggiuntivi sono disponibili. Puoi vedere tutti i componenti aggiuntivi disponibili, incluso il tipo e l'autore. Puoi anche visualizzare l'URL dei componenti aggiuntivi disponibili tramite AWS Marketplace. Sostituisci 1.35* con la versione del cluster. ``` aws eks describe-addon-versions --kubernetes-version 1.35 \ --query 'addons[].{MarketplaceProductUrl: marketplaceInformation.productUrl, Name: addonName, Owner: owner Publisher: publisher, Type: type}' --output table ``` Di seguito viene riportato un output di esempio: ``` --------------------------------------------------------------------------------------------------------------------------------------------------------- | DescribeAddonVersions | +---------------------------------------------------------------+-------------------------------+------------------+--------------+---------------------+ | MarketplaceProductUrl | Name | Owner | Publisher | Type | +---------------------------------------------------------------+-------------------------------+------------------+--------------+---------------------+ | None | aws-ebs-csi-driver | aws | eks | storage | | None | coredns | aws | eks | networking | | None | kube-proxy | aws | eks | networking | | None | vpc-cni | aws | eks | networking | | None | adot | aws | eks | observability | | https://aws.amazon.com/marketplace/pp/prodview-brb73nceicv7u | dynatrace_dynatrace-operator | aws-marketplace | dynatrace | monitoring | | https://aws.amazon.com/marketplace/pp/prodview-uhc2iwi5xysoc | upbound_universal-crossplane | aws-marketplace | upbound | infra-management | | https://aws.amazon.com/marketplace/pp/prodview-hd2ydsrgqy4li | teleport_teleport | aws-marketplace | teleport | policy-management | | https://aws.amazon.com/marketplace/pp/prodview-vgghgqdsplhvc | factorhouse_kpow | aws-marketplace | factorhouse | monitoring | | [...] | [...] | [...] | [...] | [...] | +---------------------------------------------------------------+-------------------------------+------------------+--------------+---------------------+ ``` Il tuo output potrebbe essere diverso. In questo output di esempio, sono disponibili tre diversi componenti aggiuntivi di tipo `networking` e cinque componenti aggiuntivi con un autore di tipo `eks`. I componenti aggiuntivi con `aws-marketplace` nella colonna `Owner` potrebbero richiedere un abbonamento per poter essere installati. Per ulteriori informazioni sul componente aggiuntivo e per sottoscriverlo, puoi visitare l'URL. 1. Puoi vedere quali versioni sono disponibili per ogni componente aggiuntivo. Sostituisci 1.35 con la versione del tuo cluster, quindi sostituisci vpc-cni con il nome del componente aggiuntivo restituito nella fase precedente. ``` aws eks describe-addon-versions --kubernetes-version 1.35 --addon-name vpc-cni \ --query 'addons[].addonVersions[].{Version: addonVersion, Defaultversion: compatibilities[0].defaultVersion}' --output table ``` Di seguito viene riportato un output di esempio: ``` ------------------------------------------ | DescribeAddonVersions | +-----------------+----------------------+ | Defaultversion | Version | +-----------------+----------------------+ | False | v1.12.0-eksbuild.1 | | True | v1.11.4-eksbuild.1 | | False | v1.10.4-eksbuild.1 | | False | v1.9.3-eksbuild.1 | +-----------------+----------------------+ ``` Per impostazione predefinita, la versione con `True` nella colonna `Defaultversion` è la versione con cui viene creato il componente aggiuntivo. 1. (Facoltativo) Trova le opzioni di configurazione del componente aggiuntivo scelto utilizzando il comando seguente: ``` aws eks describe-addon-configuration --addon-name vpc-cni --addon-version v1.12.0-eksbuild.1 ``` ``` { "addonName": "vpc-cni", "addonVersion": "v1.12.0-eksbuild.1", "configurationSchema": "{\"$ref\":\"#/definitions/VpcCni\",\"$schema\":\"http://json-schema.org/draft-06/schema#\",\"definitions\":{\"Cri\":{\"additionalProperties\":false,\"properties\":{\"hostPath\":{\"$ref\":\"#/definitions/HostPath\"}},\"title\":\"Cri\",\"type\":\"object\"},\"Env\":{\"additionalProperties\":false,\"properties\":{\"ADDITIONAL_ENI_TAGS\":{\"type\":\"string\"},\"AWS_VPC_CNI_NODE_PORT_SUPPORT\":{\"format\":\"boolean\",\"type\":\"string\"},\"AWS_VPC_ENI_MTU\":{\"format\":\"integer\",\"type\":\"string\"},\"AWS_VPC_K8S_CNI_CONFIGURE_RPFILTER\":{\"format\":\"boolean\",\"type\":\"string\"},\"AWS_VPC_K8S_CNI_CUSTOM_NETWORK_CFG\":{\"format\":\"boolean\",\"type\":\"string\"},\"AWS_VPC_K8S_CNI_EXTERNALSNAT\":{\"format\":\"boolean\",\"type\":\"string\"},\"AWS_VPC_K8S_CNI_LOGLEVEL\":{\"type\":\"string\"},\"AWS_VPC_K8S_CNI_LOG_FILE\":{\"type\":\"string\"},\"AWS_VPC_K8S_CNI_RANDOMIZESNAT\":{\"type\":\"string\"},\"AWS_VPC_K8S_CNI_VETHPREFIX\":{\"type\":\"string\"},\"AWS_VPC_K8S_PLUGIN_LOG_FILE\":{\"type\":\"string\"},\"AWS_VPC_K8S_PLUGIN_LOG_LEVEL\":{\"type\":\"string\"},\"DISABLE_INTROSPECTION\":{\"format\":\"boolean\",\"type\":\"string\"},\"DISABLE_METRICS\":{\"format\":\"boolean\",\"type\":\"string\"},\"DISABLE_NETWORK_RESOURCE_PROVISIONING\":{\"format\":\"boolean\",\"type\":\"string\"},\"ENABLE_POD_ENI\":{\"format\":\"boolean\",\"type\":\"string\"},\"ENABLE_PREFIX_DELEGATION\":{\"format\":\"boolean\",\"type\":\"string\"},\"WARM_ENI_TARGET\":{\"format\":\"integer\",\"type\":\"string\"},\"WARM_PREFIX_TARGET\":{\"format\":\"integer\",\"type\":\"string\"}},\"title\":\"Env\",\"type\":\"object\"},\"HostPath\":{\"additionalProperties\":false,\"properties\":{\"path\":{\"type\":\"string\"}},\"title\":\"HostPath\",\"type\":\"object\"},\"Limits\":{\"additionalProperties\":false,\"properties\":{\"cpu\":{\"type\":\"string\"},\"memory\":{\"type\":\"string\"}},\"title\":\"Limits\",\"type\":\"object\"},\"Resources\":{\"additionalProperties\":false,\"properties\":{\"limits\":{\"$ref\":\"#/definitions/Limits\"},\"requests\":{\"$ref\":\"#/definitions/Limits\"}},\"title\":\"Resources\",\"type\":\"object\"},\"VpcCni\":{\"additionalProperties\":false,\"properties\":{\"cri\":{\"$ref\":\"#/definitions/Cri\"},\"env\":{\"$ref\":\"#/definitions/Env\"},\"resources\":{\"$ref\":\"#/definitions/Resources\"}},\"title\":\"VpcCni\",\"type\":\"object\"}}}" } ``` L'output sarà uno schema JSON standard. Di seguito è riportato un esempio di valori di configurazione validi, in formato JSON, che funzionano con lo schema precedente. ``` { "resources": { "limits": { "cpu": "100m" } } } ``` Di seguito è riportato un esempio di valori di configurazione validi, in formato YAML, che funzionano con lo schema precedente. ``` resources: limits: cpu: 100m ``` 1. Stabilire se il componente aggiuntivo richiede autorizzazioni IAM. In tal caso, è necessario (1) stabilire se si desidera utilizzare EKS Pod Identity o ruoli IAM per gli account di servizio (IRSA), (2) stabilire l’ARN del ruolo IAM da utilizzare con il componente aggiuntivo e (3) stabilire il nome dell’account di servizio Kubernetes usato dal componente aggiuntivo. Per ulteriori informazioni, consulta [Recupero delle informazioni IAM su un componente aggiuntivo di Amazon EKS](retreive-iam-info.md). + Amazon EKS suggerisce di utilizzare EKS Pod Identity, se supportato dal componente aggiuntivo. Ciò richiede che l’[agente Pod Identity sia installato nel cluster](pod-identities.md). Per ulteriori informazioni sull’utilizzo di Pod Identity con i componenti aggiuntivi, consultare la pagina [Ruoli IAM per i componenti aggiuntivi di Amazon EKS](add-ons-iam.md). + Se il componente aggiuntivo o il cluster non sono configurati per EKS Pod Identity, utilizzare IRSA. [Confermare che IRSA sia configurato sul cluster.](iam-roles-for-service-accounts.md) + [Consultare la documentazione dei componenti aggiuntivi Amazon EKS per stabilire se il componente aggiuntivo richiede le autorizzazioni IAM e il nome dell’account di servizio Kubernetes associato.](eks-add-ons.md) 1. Crea un componente aggiuntivo di Amazon EKS. Copia il comando seguente sul tuo dispositivo. Apportare le seguenti modifiche al comando, se necessario, quindi esegui il comando modificato: + Sostituisci my-cluster con il nome del cluster. + Sostituisci vpc-cni con il nome del componente aggiuntivo da creare restituito nell'output del passaggio precedente. + Sostituisci version-number con il nome del componente aggiuntivo da utilizzare restituito nell'output della fase precedente. + Per installare il componente aggiuntivo in un namespace Kubernetes personalizzato, aggiungere l’opzione `--namespace-config 'namespace=`. Questa opzione è disponibile solo per i AWS componenti aggiuntivi della community. Per ulteriori informazioni, consulta [Namespace personalizzato per componenti aggiuntivi](eks-add-ons.md#custom-namespace) + Se il componente aggiuntivo non richiede le autorizzazioni IAM, elimina. + Esegui una delle seguenti operazioni: + Se il componente aggiuntivo (1) richiede le autorizzazioni IAM e (2) il cluster utilizza EKS Pod Identities, sostituiscilo con la seguente associazione di identità del pod. Sostituisci con il nome dell'account di servizio utilizzato dal componente aggiuntivo. Sostituisci con l'ARN di un ruolo IAM. Il ruolo deve disporre della policy di attendibilità richiesta da EKS Pod Identity. ``` --pod-identity-associations 'serviceAccount=,roleArn=' ``` + Se il componente aggiuntivo (1) richiede autorizzazioni IAM e (2) il cluster utilizza IRSA, sostituiscilo ** con la seguente configurazione IRSA. 111122223333Sostituiscilo con l'ID del tuo account e role-name con il nome di un ruolo IAM esistente che hai creato. Per istruzioni sulla creazione del ruolo, consultare la documentazione del componente aggiuntivo da creare. Per un elenco dei componenti aggiuntivi, consultare la pagina [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). Per specificare un ruolo per l’account di servizio è necessario disporre di un gestore OpenID Connect (OIDC) IAM per il cluster. Per stabilire se ne possiedi uno per il tuo cluster o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). ``` --service-account-role-arn arn:aws::iam::111122223333:role/role-name ``` + Questo comando di esempio sovrascrive l'opzione `--configuration-values` di qualunque versione autogestita esistente del componente aggiuntivo, se presente. Sostituiscilo con i valori di configurazione desiderati, come una stringa o un file di input. Se non si desidera fornire valori di configurazione, eliminare l’opzione `--configuration-values`. Se non desideri che la AWS CLI sovrascriva la configurazione di un componente aggiuntivo autogestito esistente, rimuovi l'opzione. --resolve-conflicts OVERWRITE Se rimuovi l'opzione e il componente aggiuntivo di Amazon EKS deve sovrascrivere la configurazione di un componente aggiuntivo autogestito esistente, la creazione del componente aggiuntivo di Amazon EKS non riesce e viene visualizzato un messaggio di errore per semplificare la soluzione del conflitto. Prima di specificare questa opzione, assicurarsi che il componente aggiuntivo Amazon EKS non gestisca le impostazioni da gestire autonomamente, perché questa opzione le sovrascrive. ``` aws eks create-addon --cluster-name my-cluster --addon-name vpc-cni --addon-version version-number \ --configuration-values '{"resources":{"limits":{"cpu":"100m"}}}' --resolve-conflicts OVERWRITE ``` ``` aws eks create-addon --cluster-name my-cluster --addon-name vpc-cni --addon-version version-number \ --configuration-values 'file://example.yaml' --resolve-conflicts OVERWRITE ``` Per un elenco completo delle opzioni disponibili, consulta ` [create-addon](https://docs.aws.amazon.com/cli/latest/reference/eks/create-addon.html) ` nella Documentazione di riferimento della riga di comando Amazon EKS. Se il componente aggiuntivo creato include `aws-marketplace` elencato nella colonna `Owner` di un passaggio precedente, la creazione potrebbe non riuscire e si potrebbe ricevere un messaggio di errore simile al seguente. ``` { "addon": { "addonName": "addon-name", "clusterName": "my-cluster", "status": "CREATE_FAILED", "addonVersion": "version", "health": { "issues": [ { "code": "AddonSubscriptionNeeded", "message": "You are currently not subscribed to this add-on. To subscribe, visit the AWS Marketplace console, agree to the seller EULA, select the pricing type if required, then re-install the add-on" } ] } } } ``` Se ricevi un errore simile a quello nell'output precedente, visita l'URL nell'output di un passaggio precedente per sottoscrivere il componente aggiuntivo. Dopo la sottoscrizione, esegui nuovamente il comando `create-addon`. # Aggiornamento di un componente aggiuntivo di Amazon EKS Amazon EKS non aggiorna automaticamente un componente aggiuntivo quando sono rilasciate nuove versioni o dopo l’aggiornamento del cluster a una nuova versione secondaria di Kubernetes. Per aggiornare un componente aggiuntivo per un cluster esistente, devi avviare l'aggiornamento. Dopo l'avvio dell'aggiornamento, Amazon EKS aggiorna automaticamente il componente aggiuntivo. Prima di aggiornare un componente aggiuntivo, consulta la documentazione attuale del componente aggiuntivo. Per un elenco dei componenti aggiuntivi disponibili, consulta [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). Se il componente aggiuntivo richiede un ruolo IAM, consulta i dettagli del componente aggiuntivo specifico in [Componenti aggiuntivi di Available Amazon EKS da AWS](workloads-add-ons-available-eks.md) per conoscere i dettagli sulla creazione del ruolo. ## Prerequisiti Completa le seguenti operazioni prima di creare un componente aggiuntivo: + Verifica se il tuo componente aggiuntivo richiede un ruolo IAM. Per ulteriori informazioni, consulta [Componenti aggiuntivi Amazon EKS](eks-add-ons.md). + Verifica che la versione del componente aggiuntivo Amazon EKS sia compatibile con il cluster. Per ulteriori informazioni, consulta [Verifica la compatibilità delle versioni aggiuntive di Amazon EKS con un cluster](addon-compat.md). ## Procedura Puoi aggiornare un componente aggiuntivo Amazon EKS utilizzando `eksctl` Console di gestione AWS, o la AWS CLI. ## Aggiornamento del componente aggiuntivo (eksctl) 1. Determina i componenti aggiuntivi e le versioni dei componenti aggiuntivi installati sul tuo cluster. Sostituisci my-cluster con il nome del cluster. ``` eksctl get addon --cluster my-cluster ``` Di seguito viene riportato un output di esempio: ``` NAME VERSION STATUS ISSUES IAMROLE UPDATE AVAILABLE coredns v1.8.7-eksbuild.2 ACTIVE 0 kube-proxy v1.23.7-eksbuild.1 ACTIVE 0 v1.23.8-eksbuild.2 vpc-cni v1.10.4-eksbuild.1 ACTIVE 0 v1.12.0-eksbuild.1,v1.11.4-eksbuild.1,v1.11.3-eksbuild.1,v1.11.2-eksbuild.1,v1.11.0-eksbuild.1 ``` L'output potrebbe avere un aspetto diverso in base ai componenti aggiuntivi e alle versioni presenti nel tuo cluster. Nell'output di esempio precedente, due componenti aggiuntivi esistenti nel cluster hanno versioni più recenti disponibili nella colonna `UPDATE AVAILABLE`. 1. Aggiorna il componente aggiuntivo. 1. Copia il comando seguente sul tuo dispositivo. Apporta le seguenti modifiche al comando in base alla necessità: + Sostituisci my-cluster con il nome del cluster. + region-codeSostituiscilo con la AWS regione in cui si trova il cluster. + Sostituisci vpc-cni con il nome del componente aggiuntivo da aggiornare restituito nell'output del passaggio precedente. + Se desideri aggiornare una versione del componente aggiuntivo precedente all'ultima versione, sostituisci latest con il numero di versione che vuoi utilizzare e che è stato restituito nell'output di un passaggio precedente. Alcuni componenti aggiuntivi includono versioni consigliate. Per ulteriori informazioni, consulta la documentazione del componente aggiuntivo che stai aggiornando. Per un elenco dei componenti aggiuntivi, consulta[AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). \$1 Se il componente aggiuntivo utilizza un account di servizio Kubernetes e un ruolo IAM, sostituiscilo 111122223333 con l'ID dell'account e role-name con il nome di un ruolo IAM esistente che hai creato. Per istruzioni sulla creazione del ruolo, consultare la documentazione del componente aggiuntivo da creare. Per un elenco dei componenti aggiuntivi, consultare la pagina [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). Per specificare un ruolo per l’account di servizio è necessario disporre di un gestore OpenID Connect (OIDC) IAM per il cluster. Per stabilire se ne possiedi uno per il tuo cluster o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). Se il componente aggiuntivo non utilizza un account di servizio Kubernetes e un ruolo IAM, elimina la riga `serviceAccountRoleARN: arn:aws: iam::111122223333:role/role-name `. + L’opzione preserve mantiene i valori esistenti per il componente aggiuntivo. Se hai impostato valori personalizzati per le impostazioni del componente aggiuntivo e non utilizzi questa opzione, Amazon EKS sovrascrive i tuoi valori con quelli predefiniti. Se utilizzi questa opzione, è preferibile testare eventuali modifiche ai campi e ai valori su un cluster non di produzione prima di aggiornare il componente aggiuntivo sul cluster di produzione. Se modifichi questo valore in `overwrite`, tutte le impostazioni vengono modificate nei valori predefiniti di Amazon EKS. Se hai impostato valori personalizzati per un’impostazione qualsiasi, è possibile che siano sovrascritti con i valori predefiniti di Amazon EKS. Se modifichi questo valore in `none`, Amazon EKS non modifica il valore di alcuna impostazione, ma l’aggiornamento potrebbe non riuscire. Se l'aggiornamento non riesce, riceverai un messaggio di errore che ti aiuterà a risolvere il conflitto. ``` cat >update-addon.yaml < 1. Aprire la [Console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters). 1. Nel pannello di navigazione a sinistra, seleziona Cluster. 1. Scegli il nome del cluster per cui aggiornare il componente aggiuntivo. 1. Selezionare la scheda Componenti aggiuntivi. 1. Scegli il componente aggiuntivo da aggiornare. 1. Scegli Modifica. 1. Nella name of addon pagina Configura, procedi come segue: 1. Scegli Versione da utilizzare. Il componente aggiuntivo potrebbe avere una versione raccomandata. Per ulteriori informazioni, consulta la documentazione del componente aggiuntivo che stai aggiornando. Per un elenco dei componenti aggiuntivi, consulta [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). 1. Sono disponibili due opzioni per configurare i ruoli per i componenti aggiuntivi: il ruolo IAM di EKS Pod Identity e i ruoli IAM per gli account di servizio (IRSA). Seguire la procedura adeguata di seguito per l’opzione preferita. Se tutti i componenti aggiuntivi selezionati includono Richiede un abbonamento sotto Stato, seleziona Avanti. Per i componenti aggiuntivi che non includono Richiede un abbonamento in Stato, procedi secondo quanto segue: 1. Per il ruolo IAM di Pod Identity per l’account di servizio, è possibile utilizzare un ruolo IAM di EKS Pod Identity esistente o crearne uno con il pulsante Crea ruolo consigliato. Questo campo indicherà solo le opzioni con la policy di attendibilità adeguata. Se non esiste alcun ruolo da selezionare, non si dispone di un ruolo esistente con una policy di attendibilità corrispondente. Per configurare un ruolo IAM di EKS Pod Identity per gli account di servizio del componente aggiuntivo selezionato, scegliere Crea ruolo consigliato. La procedura guidata per la creazione dei ruoli si apre in una finestra separata. La procedura guidata compilerà automaticamente le informazioni sul ruolo come indicato di seguito. Per ogni componente aggiuntivo in cui si desidera creare il ruolo IAM di EKS Pod Identity, completare i passaggi della procedura guidata IAM come indicato di seguito. + Nel passaggio Seleziona entità affidabile, l'opzione di AWS servizio per EKS e lo use case per EKS - Pod Identity sono preselezionati e la politica di attendibilità appropriata verrà compilata automaticamente per il componente aggiuntivo. Ad esempio, il ruolo verrà creato con la policy di attendibilità adeguata contenente il principale IAM pods.eks.amazonaws.com, come descritto nella pagina [Vantaggi delle associazioni EKS Pod Identity](pod-identities.md#pod-id-benefits). Scegli Next (Successivo). + Al passaggio Aggiungi autorizzazioni, viene preselezionata la policy gestita adeguata per la policy del ruolo per il componente aggiuntivo. Ad esempio, per il componente aggiuntivo CNI di Amazon VPC, il ruolo verrà creato con la policy gestita `AmazonEKS_CNI_Policy`, come descritto nella pagina [Plug-in della CNI di Amazon VPC per Kubernetes](workloads-add-ons-available-eks.md#add-ons-vpc-cni). Scegli Next (Successivo). + Al passaggio Nomina, verifica e crea, in Nome del ruolo, viene inserito automaticamente il nome del ruolo predefinito per il componente aggiuntivo. Ad esempio, per il componente aggiuntivo Amazon VPC CNI, il ruolo verrà creato con il nome Amazon. EKSPod IdentityAmazon VPCCNIRole In Descrizione, la descrizione predefinita viene compilata automaticamente con la descrizione adeguata per il componente aggiuntivo. Ad esempio, per il componente aggiuntivo Amazon VPC CNI, il ruolo verrà creato con la descrizione Permette ai pod in esecuzione nel cluster Amazon EKS di accedere alle risorse. AWS In Policy di attendibilità, viene visualizzata la policy di attendibilità compilata per il componente aggiuntivo. Scegli Crea ruolo. Nota Mantenere il nome del ruolo predefinito consente a EKS di preselezionare il ruolo dei componenti aggiuntivi nei nuovi cluster o quando si aggiungono componenti aggiuntivi ai cluster esistenti. È comunque possibile sostituire tale nome e il ruolo sarà disponibile per il componente aggiuntivo in tutti i cluster, ma dovrà essere selezionato manualmente dal menu a discesa. 1. Per i componenti aggiuntivi che non includono Richiede un abbonamento in Stato e per i quali si desidera configurare i ruoli utilizzando IRSA, consultare la documentazione relativa al componente aggiuntivo da creare per definire una policy IAM e collegarla a un ruolo. Per un elenco dei componenti aggiuntivi, consultare la pagina [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). Per selezionare un ruolo IAM è necessario disporre di un gestore OpenID Connect (OIDC) IAM per il cluster. Per stabilire se ne possiedi uno per il tuo cluster o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). 1. Scegliere Impostazioni di configurazione facoltative. 1. In Valori di configurazione, inserisci qualsiasi informazione di configurazione specifica del componente aggiuntivo. Per ulteriori informazioni, consulta la documentazione del componente aggiuntivo che stai aggiornando. Per un elenco di componenti aggiuntivi, consulta [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md)... per Metodo di risoluzione dei conflitti, seleziona una delle opzioni disponibili. Se hai impostato valori personalizzati per le impostazioni del componente aggiuntivo, è preferibile l'opzione Preserve (Conserva). Se non scegli questa opzione, Amazon EKS sovrascrive i tuoi valori con quelli predefiniti. Se utilizzi questa opzione, è preferibile testare eventuali modifiche ai campi e ai valori su un cluster non di produzione prima di aggiornare il componente aggiuntivo sul cluster di produzione. Se modifichi questo valore in sovrascrivi, tutte le impostazioni sono modificate nei valori predefiniti di Amazon EKS. Se hai impostato valori personalizzati per un’impostazione qualsiasi, è possibile che siano sovrascritti con i valori predefiniti di Amazon EKS. Se modifichi questo valore in nessuno, Amazon EKS non modifica il valore di alcuna impostazione, ma l’aggiornamento potrebbe non riuscire. Se l'aggiornamento non riesce, riceverai un messaggio di errore che ti aiuterà a risolvere il conflitto. 1. Scegli Save changes (Salva modifiche). ## Componente aggiuntivo di aggiornamento (AWS CLI) 1. È necessaria la versione `2.12.3` o una versione successiva `1.27.160` o una versione o successiva dell'interfaccia a riga di AWS comando (AWS CLI) installata e configurata sul dispositivo o. AWS CloudShell Per verificare la versione attuale, usa `aws --version | cut -d / -f2 | cut -d ' ' -f1`. I gestori di pacchetti come `yum` Homebrew per macOS sono spesso diverse versioni dell'ultima versione della CLI AWS . `apt-get` Per installare la versione più recente, consulta [Installazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [configurazione rapida con aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) nella Guida per l'utente dell'interfaccia a riga di AWS comando. La versione AWS CLI installata in AWS CloudShell potrebbe anche contenere diverse versioni precedenti alla versione più recente. Per aggiornarlo, consulta [Installazione della AWS CLI nella tua home directory nella Guida per](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) l'* AWS CloudShell utente. 1. Visualizza l'elenco dei componenti aggiuntivi installati. Sostituisci my-cluster* con il nome del cluster. ``` aws eks list-addons --cluster-name my-cluster ``` Di seguito viene riportato un output di esempio: ``` { "addons": [ "coredns", "kube-proxy", "vpc-cni" ] } ``` 1. Visualizza la versione corrente del componente aggiuntivo da aggiornare. Sostituisci my-cluster con il nome del tuo cluster e vpc-cni con il nome del componente aggiuntivo da aggiornare. ``` aws eks describe-addon --cluster-name my-cluster --addon-name vpc-cni --query "addon.addonVersion" --output text ``` Di seguito viene riportato un output di esempio. ``` v1.10.4-eksbuild.1 ``` 1. Determina le versioni del componente aggiuntivo disponibili per la versione del cluster. Sostituiscilo 1.35 con la versione del cluster e vpc-cni con il nome del componente aggiuntivo che desideri aggiornare. ``` aws eks describe-addon-versions --kubernetes-version 1.35 --addon-name vpc-cni \ --query 'addons[].addonVersions[].{Version: addonVersion, Defaultversion: compatibilities[0].defaultVersion}' --output table ``` Di seguito viene riportato un output di esempio. ``` ------------------------------------------ | DescribeAddonVersions | +-----------------+----------------------+ | Defaultversion | Version | +-----------------+----------------------+ | False | v1.12.0-eksbuild.1 | | True | v1.11.4-eksbuild.1 | | False | v1.10.4-eksbuild.1 | | False | v1.9.3-eksbuild.1 | +-----------------+----------------------+ ``` Per impostazione predefinita, la versione con `True` nella colonna `Defaultversion` è la versione con cui viene creato il componente aggiuntivo. 1. Aggiorna il componente aggiuntivo. Copia il comando seguente sul tuo dispositivo. Apporta le seguenti modifiche al comando, se necessario, quindi esegui il comando modificato. Per ulteriori informazioni su questo comando, consulta [update-addon](https://docs.aws.amazon.com/cli/latest/reference/eks/update-addon.html) nel Riferimento della riga di comando Amazon EKS. + Sostituisci my-cluster con il nome del cluster. + Sostituisci vpc-cni con il nome del componente aggiuntivo da aggiornare che è stato restituito nell'output di un passaggio precedente. + Sostituisci version-number con la versione a cui eseguire l'aggiornamento restituita nell'output del passaggio precedente. Alcuni componenti aggiuntivi includono versioni consigliate. Per ulteriori informazioni, consulta la documentazione del componente aggiuntivo che stai aggiornando. Per un elenco dei componenti aggiuntivi, consulta. [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md) \$1 Se il componente aggiuntivo utilizza un account di servizio Kubernetes e un ruolo IAM, sostituiscilo 111122223333 con l'ID dell'account e role-name con il nome di un ruolo IAM esistente che hai creato. Per istruzioni sulla creazione del ruolo, consultare la documentazione del componente aggiuntivo da creare. Per un elenco dei componenti aggiuntivi, consultare la pagina [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). Per specificare un ruolo per l’account di servizio è necessario disporre di un gestore OpenID Connect (OIDC) IAM per il cluster. Per stabilire se ne possiedi uno per il tuo cluster o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md). Se il componente aggiuntivo non utilizza un account di servizio Kubernetes e un ruolo IAM, elimina la riga `serviceAccountRoleARN: arn:aws: iam::111122223333:role/role-name `. + L’opzione `--resolve-conflicts PRESERVE` mantiene i valori esistenti per il componente aggiuntivo. Se hai impostato valori personalizzati per le impostazioni del componente aggiuntivo e non utilizzi questa opzione, Amazon EKS sovrascrive i tuoi valori con quelli predefiniti. Se utilizzi questa opzione, è preferibile testare eventuali modifiche ai campi e ai valori su un cluster non di produzione prima di aggiornare il componente aggiuntivo sul cluster di produzione. Se modifichi questo valore in `OVERWRITE`, tutte le impostazioni vengono modificate nei valori predefiniti di Amazon EKS. Se hai impostato valori personalizzati per un’impostazione qualsiasi, è possibile che siano sovrascritti con i valori predefiniti di Amazon EKS. Se modifichi questo valore in `NONE`, Amazon EKS non modifica il valore di alcuna impostazione, ma l’aggiornamento potrebbe non riuscire. Se l'aggiornamento non riesce, riceverai un messaggio di errore che ti aiuterà a risolvere il conflitto. + Se desideri rimuovere tutte le configurazioni personalizzate, esegui l'aggiornamento utilizzando l'opzione --configuration-values '\$1\$1'. In tal modo, verranno ripristinati i valori predefiniti di tutte le configurazioni personalizzate. Se non desideri modificare la configurazione personalizzata, non fornire il flag. --configuration-values Per modificare una configurazione personalizzata, sostituisci \$1\$1 con i nuovi parametri. ``` aws eks update-addon --cluster-name my-cluster --addon-name vpc-cni --addon-version version-number \ --service-account-role-arn arn:aws: iam::111122223333:role/role-name --configuration-values '{}' --resolve-conflicts PRESERVE ``` 1. Controlla lo stato dell'aggiornamento. Sostituiscilo my-cluster con il nome del cluster e vpc-cni con il nome del componente aggiuntivo che stai aggiornando. ``` aws eks describe-addon --cluster-name my-cluster --addon-name vpc-cni ``` Di seguito viene riportato un output di esempio. ``` { "addon": { "addonName": "vpc-cni", "clusterName": "my-cluster", "status": "UPDATING", } } ``` L'aggiornamento è completo quando lo stato è `ACTIVE`. # Verifica la compatibilità delle versioni aggiuntive di Amazon EKS con un cluster Prima di creare un componente aggiuntivo di Amazon EKS, devi verificare che la versione del componente aggiuntivo di Amazon EKS sia compatibile con il cluster. Utilizza l'[describe-addon-versions API](https://docs.aws.amazon.com/eks/latest/APIReference/API_DescribeAddonVersions.html) per elencare le versioni disponibili dei componenti aggiuntivi EKS e le versioni di Kubernetes supportate da ciascuna versione del componente aggiuntivo. 1. Verifica che la AWS CLI sia installata e funzionante. `aws sts get-caller-identity` Se questo comando non funziona, scopri come [iniziare a usare la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html). 1. Determina il nome del componente aggiuntivo per il quale recuperare le informazioni sulla compatibilità della versione, ad esempio `amazon-cloudwatch-observability`. 1. Determina la versione di Kubernetes per il cluster, ad esempio `1.35`. 1. Usa la AWS CLI per recuperare le versioni del componente aggiuntivo compatibili con la versione Kubernetes del tuo cluster. ``` aws eks describe-addon-versions --addon-name amazon-cloudwatch-observability --kubernetes-version 1.35 ``` Di seguito viene riportato un output di esempio. ``` { "addons": [ { "addonName": "amazon-cloudwatch-observability", "type": "observability", "addonVersions": [ { "addonVersion": "vX.X.X-eksbuild.X", "architecture": [ "amd64", "arm64" ], "computeTypes": [ "ec2", "auto", "hybrid" ], "compatibilities": [ { "clusterVersion": "1.35", "platformVersions": [ "" ], "defaultVersion": true } ], } ] } ] } ``` Questo output mostra che la versione `vX.X.X-eksbuild.X` del componente aggiuntivo è compatibile con quella `1.35` del cluster di Kubernetes. ## Compatibilità del componente aggiuntivo con i tipi di elaborazione Il campo `computeTypes` nell’output `describe-addon-versions` indica la compatibilità di un componente aggiuntivo con i nodi gestiti dalla modalità automatica di EKS o i nodi ibridi. I componenti aggiuntivi contrassegnati `auto` funzionano con l'infrastruttura AWS gestita basata sul cloud di EKS Auto Mode, mentre quelli contrassegnati `hybrid` possono essere eseguiti su nodi locali collegati al piano di controllo cloud EKS. Per ulteriori informazioni, consulta [Considerazioni per la modalità automatica di Amazon EKS](eks-add-ons.md#addon-consider-auto). # Rimozione di un componente aggiuntivo Amazon EKS da un cluster Puoi rimuovere un componente aggiuntivo Amazon EKS dal tuo cluster utilizzando `eksctl` Console di gestione AWS, o la AWS CLI. Quando rimuovi un componente aggiuntivo Amazon EKS da un cluster: + non sono previste interruzioni per la funzionalità fornita dal componente aggiuntivo. + Se utilizzi ruoli IAM per account di servizio (IRSA) e al componente aggiuntivo è associato un ruolo IAM, il ruolo IAM non è rimosso. + Se utilizzi Pod Identity, tutte le associazioni Pod Identity di proprietà del componente aggiuntivo sono rimosse. Se si specifica l'`--preserve`opzione nella AWS CLI, le associazioni vengono mantenute. + Amazon EKS interrompe la gestione delle impostazioni per il componente aggiuntivo. + La console smette di segnalarti la disponibilità di nuove versioni. + Non è possibile aggiornare il componente aggiuntivo utilizzando AWS strumenti o. APIs + Puoi scegliere di lasciare il software del componente aggiuntivo nel tuo cluster in modo da poterlo gestire autonomamente, oppure puoi rimuoverlo. È opportuno rimuovere il software del componente aggiuntivo dal tuo cluster se non esistono risorse sul cluster che dipendono dalla funzionalità fornita dal componente aggiuntivo. ## Prerequisiti Completa le seguenti operazioni prima di creare un componente aggiuntivo: + Un cluster Amazon EKS esistente. Per implementarne uno, consulta [Nozioni di base su Amazon EKS](getting-started.md). + Verifica se il tuo componente aggiuntivo richiede un ruolo IAM. Per ulteriori informazioni, consultare la pagina + La versione `0.215.0` o quelle successive dello strumento a riga di comando `eksctl` deve essere installata sul dispositivo o nella AWS CloudShell. Per l’installazione o l’aggiornamento di `eksctl`, consulta [Installazione](https://eksctl.io/installation) nella documentazione di `eksctl`. ## Procedura Sono possibili due opzioni per rimuovere un componente aggiuntivo Amazon EKS: + Mantenere il software aggiuntivo sul cluster – Questa opzione rimuove la gestione di Amazon EKS su qualsiasi impostazione. Inoltre, rimuove la possibilità per Amazon EKS di notificare gli aggiornamenti e aggiornare automaticamente il componente aggiuntivo Amazon EKS dopo l'avvio di un aggiornamento. Tuttavia, mantiene il software aggiuntivo sul cluster. Questa opzione rende il componente aggiuntivo come autogestito anziché come un componente aggiuntivo Amazon EKS. Con questa opzione, non ci sono tempi di inattività per il componente aggiuntivo. + Rimuovere completamente il software aggiuntivo dal cluster – Consigliamo di rimuovere il componente aggiuntivo Amazon EKS dal cluster solo se non ci sono risorse nel cluster che dipendono dallo stesso. Puoi rimuovere un componente aggiuntivo Amazon EKS utilizzando `eksctl` Console di gestione AWS, o la AWS CLI. ### Rimuovere un componente aggiuntivo (eksctl) 1. Determina i componenti aggiuntivi installati sul tuo cluster. Sostituisci my-cluster* con il nome del cluster. ``` eksctl get addon --cluster my-cluster ``` Di seguito viene riportato un output di esempio: ``` NAME VERSION STATUS ISSUES IAMROLE UPDATE AVAILABLE coredns v1.8.7-eksbuild.2 ACTIVE 0 kube-proxy v1.23.7-eksbuild.1 ACTIVE 0 vpc-cni v1.10.4-eksbuild.1 ACTIVE 0 [...] ``` L'output potrebbe avere un aspetto diverso in base ai componenti aggiuntivi e alle versioni presenti nel tuo cluster. 1. Rimuovi il componente aggiuntivo. Sostituisci my-cluster con il nome del cluster e name-of-add-on con il nome del componente aggiuntivo da rimuovere restituito nell'output del passaggio precedente. Se rimuovi l'--preserveopzione, oltre al fatto che Amazon EKS non gestisce più il componente aggiuntivo, il software aggiuntivo viene eliminato dal cluster. ``` eksctl delete addon --cluster my-cluster --name name-of-addon --preserve ``` Per ulteriori informazioni sulla rimozione dei componenti aggiuntivi, consulta [Eliminare componenti aggiuntivi](https://eksctl.io/usage/addons/#deleting-addons) nella documentazione di `eksctl`. ### Rimuovi componente aggiuntivo (console)AWS 1. Aprire la [Console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters). 1. Nel pannello di navigazione a sinistra, seleziona Cluster. 1. Scegli il nome del cluster per cui desideri rimuovere il componente aggiuntivo di Amazon EBS. 1. Selezionare la scheda Componenti aggiuntivi. 1. Scegli il componente aggiuntivo che vuoi rimuovere. 1. Scegli Rimuovi. 1. Nella finestra di dialogo **Rimuovi: name of addon conferma, effettuate le seguenti operazioni: 1. Se desideri che Amazon EKS interrompa la gestione delle impostazioni per il componente aggiuntivo, seleziona Mantieni sul cluster. Effettuare questa operazione se si desidera conservare il software aggiuntivo sul cluster. In questo modo sarà possibile gestire autonomamente tutte le impostazioni del componente aggiuntivo. 1. Inserisci il nome del componente aggiuntivo. 1. Scegli Rimuovi**. ### Rimuovi componente aggiuntivo (AWS CLI) 1. È necessaria la versione `0.215.0` o una versione successiva dello strumento da riga di `eksctl` comando installata sul dispositivo o. AWS CloudShell Per l’installazione o l’aggiornamento di `eksctl`, consulta la sezione [Installation](https://eksctl.io/installation) nella documentazione di `eksctl`. 1. Visualizza l'elenco dei componenti aggiuntivi installati. Sostituisci my-cluster con il nome del cluster. ``` aws eks list-addons --cluster-name my-cluster ``` Di seguito viene riportato un output di esempio. ``` { "addons": [ "coredns", "kube-proxy", "vpc-cni", "name-of-addon" ] } ``` 1. Rimuovi il componente aggiuntivo installato. Sostituisci my-cluster con il nome del tuo cluster e name-of-add-on con il nome del componente aggiuntivo da rimuovere. La rimozione --preserve comporta l'eliminazione del software aggiuntivo dal cluster. ``` aws eks delete-addon --cluster-name my-cluster --addon-name name-of-addon --preserve ``` Di seguito è riportato un output di esempio abbreviato. ``` { "addon": { "addonName": "name-of-add-on", "clusterName": "my-cluster", "status": "DELETING", } } ``` 1. Controlla lo stato della rimozione. Sostituiscilo my-cluster con il nome del cluster e name-of-addon con il nome del componente aggiuntivo che stai rimuovendo. ``` aws eks describe-addon --cluster-name my-cluster --addon-name name-of-addon ``` Di seguito è riportato l’output esemplificativo dopo la rimozione del componente aggiuntivo. ``` An error occurred (ResourceNotFoundException) when calling the DescribeAddon operation: No addon: name-of-addon found in cluster: my-cluster ``` # Ruoli IAM per i componenti aggiuntivi di Amazon EKS Alcuni componenti aggiuntivi Amazon EKS richiedono ruoli IAM e autorizzazioni per chiamare le API AWS. Ad esempio, il componente aggiuntivo CNI di Amazon VPC richiama determinate API AWS per configurare le risorse di rete nell’account. A questi componenti aggiuntivi deve essere concessa l’autorizzazione tramite IAM. Più specificamente, l’account di servizio del pod che esegue il componente aggiuntivo deve essere associato a un ruolo IAM con una policy IAM specifica. Il modo consigliato per concedere autorizzazioni AWS ai carichi di lavoro del cluster è utilizzare la funzionalità di Pod Identity di Amazon EKS. Puoi utilizzare un’associazione di Pod Identity per mappare l’account di servizio di un componente aggiuntivo a un ruolo IAM. Se un pod utilizza un account di servizio con un’associazione, Amazon EKS imposta le variabili di ambiente nei container del pod. Le variabili di ambiente configurano AWS SDK, inclusa AWS CLI, per utilizzare le credenziali di EKS Pod Identity. Per ulteriori informazioni, consulta [Informazioni su come EKS Pod Identity consente ai pod di accedere ai servizi AWS](pod-identities.md) I componenti aggiuntivi di Amazon EKS possono aiutare a gestire il ciclo di vita delle associazioni di Pod Identity corrispondenti al componente aggiuntivo. Ad esempio, puoi creare o aggiornare un componente aggiuntivo di Amazon EKS e l’associazione di Pod Identity necessaria in una singola chiamata API. Amazon EKS fornisce anche un’API per il recupero delle policy IAM suggerite. 1. Conferma che l’[agente Pod Identity di Amazon EKS](pod-id-agent-setup.md) sia configurato sul cluster. 1. Determina se il componente aggiuntivo che si desidera installare richiede le autorizzazioni IAM utilizzando l’operazione `describe-addon-versions` su AWS CLI. Se il flag `requiresIamPermissions` è `true`, allora dovresti usare l’operazione `describe-addon-configurations` per determinare le autorizzazioni necessarie al componente aggiuntivo. La risposta include un elenco di policy IAM gestite suggerite. 1. Recupera il nome dell’account di servizio Kubernetes e la policy IAM utilizzando l’operazione `describe-addon-configuration` CLI. Valuta l’ambito della policy suggerita rispetto ai requisiti di sicurezza. 1. Crea un ruolo IAM utilizzando la policy di autorizzazioni suggerita e la policy di attendibilità richiesta da Pod Identity. Per ulteriori informazioni, consulta [Crea un'associazione Pod Identity (AWS Console)](pod-id-association.md#pod-id-association-create). 1. Crea o aggiorna un componente aggiuntivo Amazon EKS utilizzando la CLI. Specifica almeno un’associazione di Pod Identity. Un’associazione di Pod Identity è il nome di un account di servizio Kubernetes e l’ARN del ruolo IAM. + Le associazioni di Pod Identity create utilizzando le API del componente aggiuntivo sono di proprietà del rispettivo componente aggiuntivo. Se elimini il componente aggiuntivo, viene eliminata anche l’associazione di Pod Identity. Puoi impedire questa eliminazione a cascata utilizzando l’opzione `preserve` quando si elimina un componente aggiuntivo utilizzando la AWS CLI o l’API. Se necessario, puoi anche aggiornare o eliminare direttamente l’associazione di Pod Identity. I componenti aggiuntivi non possono assumere la proprietà delle associazioni di Pod Identity esistenti. Devi eliminare l’associazione esistente e ricrearla usando un’operazione di creazione o aggiornamento di un componente aggiuntivo. + Amazon EKS consiglia di utilizzare le associazioni di Pod Identity per gestire le autorizzazioni IAM per i componenti aggiuntivi. Il metodo precedente, ruoli IAM per account di servizio (IRSA), è ancora supportato. Puoi specificare sia un `serviceAccountRoleArn` IRSA che un’associazione di Pod Identity per un componente aggiuntivo. Se l’agente Pod Identity EKS è installato nel cluster, l’`serviceAccountRoleArn` verrà ignorato ed EKS utilizzerà l’associazione di Pod Identity fornita. Se Pod Identity non è abilitato, verrà utilizzato l’`serviceAccountRoleArn`. + Se aggiorni le associazioni di Pod Identity per un componente aggiuntivo esistente, Amazon EKS avvia un riavvio in sequenza dei pod del componente aggiuntivo. # Recupero delle informazioni IAM su un componente aggiuntivo di Amazon EKS Prima di creare un componente aggiuntivo, utilizza AWS CLI per determinare: + Se il componente aggiuntivo richiede le autorizzazioni IAM + La policy IAM consigliata da utilizzare ## Procedura 1. Determina il nome del componente aggiuntivo che desideri installare e la versione Kubernetes del tuo cluster. Per ulteriori informazioni sui componenti aggiuntivi, consulta [Componenti aggiuntivi Amazon EKS](eks-add-ons.md). 1. Utilizza AWS CLI per stabilire se il componente aggiuntivo richiede autorizzazioni IAM. ``` aws eks describe-addon-versions \ --addon-name \ --kubernetes-version ``` Per esempio: ``` aws eks describe-addon-versions \ --addon-name aws-ebs-csi-driver \ --kubernetes-version 1.30 ``` Esamina il seguente output esemplificativo. Tieni presente che `requiresIamPermissions` è `true` e la versione del componente aggiuntivo predefinita. È necessario specificare la versione del componente aggiuntivo quando si recupera la policy IAM consigliata. ``` { "addons": [ { "addonName": "aws-ebs-csi-driver", "type": "storage", "addonVersions": [ { "addonVersion": "v1.31.0-eksbuild.1", "architecture": [ "amd64", "arm64" ], "compatibilities": [ { "clusterVersion": "1.30", "platformVersions": [ "" ], "defaultVersion": true } ], "requiresConfiguration": false, "requiresIamPermissions": true }, [...] ``` 1. Se il componente aggiuntivo richiede autorizzazioni IAM, utilizza AWS CLI per recuperare una policy IAM consigliata. ``` aws eks describe-addon-configuration \ --query podIdentityConfiguration \ --addon-name \ --addon-version ``` Per esempio: ``` aws eks describe-addon-configuration \ --query podIdentityConfiguration \ --addon-name aws-ebs-csi-driver \ --addon-version v1.31.0-eksbuild.1 ``` Esamina l’output successivo. Prendi nota di `recommendedManagedPolicies`. ``` [ { "serviceAccount": "ebs-csi-controller-sa", "recommendedManagedPolicies": [ "arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy" ] } ] ``` 1. Crea un ruolo IAM e collega la policy gestita consigliata. In alternativa, riconsulta la policy gestita e definisci le autorizzazioni in modo appropriato. Per ulteriori informazioni, consulta [Crea un'associazione Pod Identity (AWS Console)](pod-id-association.md#pod-id-association-create). ## Riferimento di supporto Pod Identity La tabella seguente indica se determinati componenti aggiuntivi di Amazon EKS supportano EKS Pod Identity. | Nome del componente aggiuntivo | Supporto di Pod Identity | Versione minima richiesta | | --- | --- | --- | | [Driver CSI per Amazon EBS](workloads-add-ons-available-eks.md#add-ons-aws-ebs-csi-driver) | Sì | v1.26.0-eksbuild.1 | | [CNI di Amazon VPC](workloads-add-ons-available-eks.md#add-ons-vpc-cni) | Sì | v1.15.5-eksbuild.1 | | [Driver CSI per Amazon EFS](workloads-add-ons-available-eks.md#add-ons-aws-efs-csi-driver) | Sì | v2.0.5-eksbuild.1 | | [AWS Distro per OpenTelemetry](workloads-add-ons-available-eks.md#add-ons-adot) | Sì | v0.94.1-eksbuild.1 | | [Driver CSI di Mountpoint per Amazon S3](workloads-add-ons-available-eks.md#mountpoint-for-s3-add-on) | No | N/D | | [Agente Osservabilità di Amazon CloudWatch](workloads-add-ons-available-eks.md#amazon-cloudwatch-observability) | Sì | v3.1.0-eksbuild.1 | L’ultimo aggiornamento di questa tabella risale al 28 ottobre 2024. # Utilizzo di Pod Identity per assegnare un ruolo IAM a un componente aggiuntivo Amazon EKS Alcuni componenti aggiuntivi Amazon EKS richiedono ruoli IAM e autorizzazioni. Prima di aggiungere o aggiornare un componente aggiuntivo Amazon EKS per utilizzare un’associazione Pod Identity, verifica il ruolo e la policy da utilizzare. Per ulteriori informazioni, consulta [Recupero delle informazioni IAM su un componente aggiuntivo di Amazon EKS](retreive-iam-info.md). 1. Determina: + `cluster-name`: il nome del cluster su cui installare il componente aggiuntivo. + `addon-name`: il nome del componente aggiuntivo da installare. + `service-account-name`: il nome dell’account di servizio Kubernetes utilizzato dal componente aggiuntivo. + `iam-role-arn`: l’ARN di un ruolo IAM con le autorizzazioni sufficienti per il componente aggiuntivo. Il ruolo deve disporre della policy di attendibilità richiesta per EKS Pod Identity. Per ulteriori informazioni, consulta [Crea un'associazione Pod Identity (AWS Console)](pod-id-association.md#pod-id-association-create). 1. Aggiorna il componente aggiuntivo utilizzando AWS CLI. È anche possibile specificare le associazioni Pod Identity durante la creazione di un componente aggiuntivo, utilizzando la stessa sintassi `--pod-identity-assocations`. Nota che quando specifichi le associazioni di Pod Identity durante l’aggiornamento di un componente aggiuntivo, tutte le associazioni di Pod Identity precedenti sono sovrascritte. ``` aws eks update-addon --cluster-name \ --addon-name \ --pod-identity-associations 'serviceAccount=,roleArn=' ``` Per esempio: ``` aws eks update-addon --cluster-name mycluster \ --addon-name aws-ebs-csi-driver \ --pod-identity-associations 'serviceAccount=ebs-csi-controller-sa,roleArn=arn:aws:iam::123456789012:role/StorageDriver' ``` 1. Convalida che l’associazione Pod Identity sia stata creata: ``` aws eks list-pod-identity-associations --cluster-name ``` A operazione riuscita, viene visualizzato un output simile al seguente. Nota OwnerARN del componente aggiuntivo EKS. ``` { "associations": [ { "clusterName": "mycluster", "namespace": "kube-system", "serviceAccount": "ebs-csi-controller-sa", "associationArn": "arn:aws:eks:us-west-2:123456789012:podidentityassociation/mycluster/a-4wvljrezsukshq1bv", "associationId": "a-4wvljrezsukshq1bv", "ownerArn": "arn:aws:eks:us-west-2:123456789012:addon/mycluster/aws-ebs-csi-driver/9cc7ce8c-2e15-b0a7-f311-426691cd8546" } ] } ``` # Rimozione delle associazioni Pod Identity da un componente aggiuntivo Amazon EKS Rimuovi le associazioni Pod Identity da un componente aggiuntivo Amazon EKS. 1. Determina: + `cluster-name`: il nome del cluster EKS su cui installare il componente aggiuntivo. + `addon-name`: Il nome del componente aggiuntivo Amazon EKS da installare. 1. Aggiorna il componente aggiuntivo per specificare un array vuoto di associazioni di Pod Identity. ``` aws eks update-addon --cluster-name \ --addon-name \ --pod-identity-associations "[]" ``` # Risoluzione dei problemi in Pod Identity per i componenti aggiuntivi di EKS Se i componenti aggiuntivi riscontrano errori durante il tentativo di eseguire operazioni su AWS API, SDK o CLI, conferma quanto segue: + L’agente Pod Identity è installato nel cluster. + Per informazioni su come installare l’agente Pod Identity, consulta [Configurazione dell’agente Amazon EKS Pod Identity](pod-id-agent-setup.md). + Il componente aggiuntivo ha un’associazione di Pod Identity valida. + Utilizza AWS CLI per recuperare le associazioni per il nome dell’account di servizio utilizzato dal componente aggiuntivo. ``` aws eks list-pod-identity-associations --cluster-name ``` + Il ruolo IAM dispone della policy di attendibilità richiesta per Pod Identity. + Utilizza AWS CLI per recuperare la policy di attendibilità per un componente aggiuntivo. ``` aws iam get-role --role-name --query Role.AssumeRolePolicyDocument ``` + Il ruolo IAM dispone delle autorizzazioni necessarie per il componente aggiuntivo. + Usa AWS CloudTrail per rivedere gli eventi `AccessDenied` o `UnauthorizedOperation`. + Il nome dell’account di servizio nell’associazione di Pod Identity corrisponde al nome dell’account di servizio utilizzato dal componente aggiuntivo. + Per informazioni sui componenti aggiuntivi disponibili, consulta [AWS componenti aggiuntivi](workloads-add-ons-available-eks.md). + Verifica la configurazione di MutatingWebhookConfiguration denominata `pod-identity-webhook` + `admissionReviewVersions` del webhook deve essere `v1beta1` e non funziona con `v1`. # Determina i campi che puoi personalizzare per i componenti aggiuntivi Amazon EKS I componenti aggiuntivi Amazon EKS vengono installati nel cluster utilizzando configurazioni standard e best practice. Per ulteriori informazioni sull’aggiunta di un componente aggiuntivo di Amazon EKS al cluster, consulta [Componenti aggiuntivi Amazon EKS](eks-add-ons.md). Potresti voler personalizzare la configurazione di un componente aggiuntivo Amazon EKS per abilitare funzionalità avanzate. Amazon EKS utilizza la funzionalità applicazione lato server Kubernetes per abilitare la gestione di un componente aggiuntivo da parte di Amazon EKS, senza sovrascrivere la configurazione per le impostazioni non gestite da Amazon EKS. Per ulteriori informazioni, consulta [Applicazione lato server](https://kubernetes.io/docs/reference/using-api/server-side-apply/) nella documentazione di Kubernetes. Per raggiungere questo obiettivo, Amazon EKS gestisce un insieme minimo di campi per ogni componente aggiuntivo che installa. Puoi modificare senza problemi tutti i campi non gestiti da Amazon EKS o da un altro processo del piano di controllo Kubernetes, come `kube-controller-manager`. Importante La modifica di un campo gestito da Amazon EKS impedisce ad Amazon EKS di gestire il componente aggiuntivo e può comportare la sovrascrittura delle modifiche quando un componente aggiuntivo viene aggiornato. ## Sintassi della gestione dei campi Quando si visualizzano i dettagli di un oggetto Kubernetes, nell’output vengono restituiti sia i campi gestiti che quelli non gestiti. I campi gestiti possono essere dei seguenti tipi: + Completamente gestito – Tutte le chiavi del campo sono gestite da Amazon EKS. Le modifiche a qualsiasi valore causano un conflitto. + Parzialmente gestiti – Alcune chiavi per il campo sono gestite da Amazon EKS. Solo le modifiche alle chiavi gestite esplicitamente da Amazon EKS causano un conflitto. Entrambi i tipi di campi sono taggati con `manager: eks`. Ogni chiave è un `.` che rappresenta il campo stesso, che viene sempre mappato a un insieme vuoto o a una stringa che rappresenta un sottocampo o un elemento. L'output per la gestione del campo è costituito dai seguenti tipi di dichiarazioni: + `f:name `, dove name* è il nome di un campo in un elenco. + `k:keys `, dove keys è una mappa dei campi di una voce di elenco. + `v:value `, dove value è il valore formattato JSON esatto di una elemento in elenco. + `i:index `, dove index è la posizione di un elemento nell'elenco. Le seguenti porzioni di output per il componente aggiuntivo CoreDNS illustrano le dichiarazioni precedenti: + Campi completamente gestiti – Se un campo gestito ha un `f:` (campo) specificato, ma non `k:` (chiave), l’intero campo è gestito. Le modifiche apportate a qualsiasi valore in questo campo causano un conflitto. Nel seguente output, è possibile vedere che il container denominato `coredns` è gestito da `eks`. La `args`, `image`, e i sottocampi `imagePullPolicy` sono gestiti anche da `eks`. Le modifiche a qualsiasi valore in questi campi causano un conflitto. ``` [...] f:containers: k:{"name":"coredns"}: .: {} f:args: {} f:image: {} f:imagePullPolicy: {} [...] manager: eks [...] ``` + Campi parzialmente gestiti – Se una chiave gestita ha un valore specificato, le chiavi dichiarate vengono gestite per quel campo. La modifica delle chiavi specificate causa un conflitto. Nel seguente output, è possibile vedere che `eks` gestisce il `config-volume` e volumi `tmp` impostati con la chiave `name`. ``` [...] f:volumes: k:{"name":"config-volume"}: .: {} f:configMap: f:items: {} f:name: {} f:name: {} k:{"name":"tmp"}: .: {} f:name: {} [...] manager: eks [...] ``` + Aggiunta di chiavi a campi parzialmente gestiti – Se viene gestita solo una chiave-valore specifica, è possibile aggiungere ulteriori chiavi, ad esempio, argomenti, a un campo senza causare conflitti. Se aggiungi altre chiavi, assicurati per prima cosa che il campo non sia gestito. L’aggiunta o la modifica di qualsiasi valore gestito causa un conflitto. Nel seguente output, è possibile vedere come sia la chiave `name` che il campo `name` siano gestiti. L’aggiunta o la modifica di qualsiasi nome container causa un conflitto con questa chiave gestita. ``` [...] f:containers: k:{"name":"coredns"}: [...] f:name: {} [...] manager: eks [...] ``` ## Procedura È possibile utilizzare `kubectl` per vedere quali campi sono gestiti da Amazon EKS per qualsiasi componente aggiuntivo Amazon EKS. Puoi modificare senza problemi tutti i campi non gestiti da Amazon EKS o da un altro processo del piano di controllo Kubernetes, come `kube-controller-manager`. 1. Determinare quale componente aggiuntivo si desidera esaminare. Per visualizzare tutti i file `deployments` e DaemonSets distribuiti nel cluster, consulta[Visualizza le risorse Kubernetes nel Console di gestione AWS](view-kubernetes-resources.md). 1. Visualizzazione dei campi gestiti per un componente aggiuntivo eseguendo il comando seguente: ``` kubectl get type/add-on-name -n add-on-namespace -o yaml ``` Ad esempio, è possibile visualizzare i campi gestiti per il componente aggiuntivo CoreDNS con il comando seguente. ``` kubectl get deployment/coredns -n kube-system -o yaml ``` La gestione dei campi è elencata nella sezione seguente dell’output restituito. ``` [...] managedFields: - apiVersion: apps/v1 fieldsType: FieldsV1 fieldsV1: [...] ``` Nota Se non visualizzi `managedFields` nell’output, aggiungi `--show-managed-fields` al comando ed eseguilo di nuovo. La versione di `kubectl` che stai utilizzando determina se i campi gestiti vengono restituiti per impostazione predefinita. ## Fasi successive Personalizza i campi non di proprietà del componente aggiuntivo AWS for you. # Convalida le firme delle immagini dei container durante l’implementazione Se utilizzi [AWS Signer](https://docs.aws.amazon.com/signer/latest/developerguide/Welcome.html) e desideri verificare le immagini dei container firmate al momento dell’implementazione, puoi utilizzare una delle seguenti soluzioni: + [Gatekeeper e Ratify](https://ratify.dev/docs/1.0/quickstarts/ratify-on-aws): usa Gatekeeper come controller di ammissione e Ratify configurato con un plug-in AWS Signer come Web hook per la convalida delle firme. + [Kyverno](https://github.com/nirmata/kyverno-notation-aws): un motore di policy di Kubernetes configurato con un plug-in AWS Signer per la convalida delle firme. Nota Prima di verificare le firme delle immagini del container, configura l’archivio di attendibilità e la policy di attendibilità di [Notation](https://github.com/notaryproject/notation#readme), come richiesto dal controller di ammissione selezionato.