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à.

# Abilitazione AWS Resilience Hub dell'accesso al tuo cluster Amazon Elastic Kubernetes Service
<a name="enabling-eks-in-arh"></a>

AWS Resilience Hub valuta la resilienza di un cluster Amazon Elastic Kubernetes Service (Amazon EKS) analizzando l'infrastruttura del cluster Amazon EKS. AWS Resilience Hub utilizza la configurazione RBAC (role-based access control) di Kubernetes per valutare altri carichi di lavoro Kubernetes (K8s), che vengono distribuiti come parte del cluster Amazon EKS. AWS Resilience Hub Per interrogare il cluster Amazon EKS per l'analisi e la valutazione del carico di lavoro, devi completare quanto segue:
+ Crea o usa un ruolo esistente AWS Identity and Access Management (IAM) nello stesso account del cluster Amazon EKS.
+ Abilita l'accesso di utenti e ruoli IAM al tuo cluster Amazon EKS e concedi autorizzazioni di sola lettura aggiuntive alle risorse K8s all'interno del cluster Amazon EKS. Per ulteriori informazioni sull'abilitazione dell'accesso di utenti e ruoli IAM al tuo cluster Amazon EKS, consulta [Abilitare l'accesso di utenti e ruoli IAM al tuo cluster - Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html).

L'accesso al tuo cluster Amazon EKS tramite entità IAM è abilitato da [AWS IAM Authenticator for Kubernetes](https://github.com/kubernetes-sigs/aws-iam-authenticator#readme), che viene eseguito sul piano di controllo di Amazon EKS. L'Authenticator ottiene le informazioni di configurazione da. `aws-auth ConfigMap`

**Nota**  
Per ulteriori informazioni su tutte le `aws-auth ConfigMap` impostazioni, consulta [Full Configuration](https://github.com/kubernetes-sigs/aws-iam-authenticator#full-configuration-format) Format on. GitHub
Per ulteriori informazioni sulle diverse identità IAM, consulta [Identità (utenti, gruppi e ruoli)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) nella Guida per l'utente IAM.
[Per ulteriori informazioni sulla configurazione del controllo degli accessi basato sui ruoli (RBAC) di Kubernetes, consulta Using RBAC Authorization.](https://kubernetes.io/docs/reference/access-authn-authz/rbac/)

AWS Resilience Hub interroga le risorse all'interno del tuo cluster Amazon EKS utilizzando un ruolo IAM nel tuo account. Per accedere AWS Resilience Hub alle risorse all'interno del cluster Amazon EKS, il ruolo IAM utilizzato da AWS Resilience Hub deve essere mappato su un gruppo Kubernetes con autorizzazioni di sola lettura sufficienti per le risorse all'interno del cluster Amazon EKS.

AWS Resilience Hub consente di accedere alle risorse del cluster Amazon EKS utilizzando una delle seguenti opzioni di ruolo IAM:
+ Se l'applicazione è configurata per utilizzare l'accesso basato sui ruoli per accedere alle risorse, il ruolo invoker o il ruolo di account secondario assegnato AWS Resilience Hub durante la creazione di un'applicazione verrà utilizzato per accedere al cluster Amazon EKS durante la valutazione. 

  Il seguente diagramma concettuale mostra come accedere AWS Resilience Hub ai cluster Amazon EKS quando l'applicazione è configurata come applicazione basata sui ruoli.  
![\[Diagram showing AWS Resilience Hub accessing EKS clusters in primary and secondary accounts.\]](http://docs.aws.amazon.com/it_it/resilience-hub/latest/userguide/images/EKS-accounts.png)
+ Se la tua applicazione è configurata per utilizzare l'utente IAM corrente per accedere alle risorse, devi creare un nuovo ruolo IAM con il nome `AwsResilienceHubAssessmentEKSAccessRole` nello stesso account del cluster Amazon EKS. Questo ruolo IAM verrà quindi utilizzato per accedere al tuo cluster Amazon EKS.

  Il seguente diagramma concettuale mostra come AWS Resilience Hub accedere ai cluster Amazon EKS distribuiti nel tuo account principale quando l'applicazione è configurata per utilizzare le attuali autorizzazioni utente IAM.  
![\[Icons representing login, current IAM role, assume role, and AWS Resilience Hub options.\]](http://docs.aws.amazon.com/it_it/resilience-hub/latest/userguide/images/SingleAccountEKS.png)

  Il seguente diagramma concettuale mostra come AWS Resilience Hub accede ai cluster Amazon EKS distribuiti su un account secondario quando l'applicazione è configurata per utilizzare le attuali autorizzazioni utente IAM.  
![\[Icons representing Account AWS access roles and permissions for primary and secondary accounts.\]](http://docs.aws.amazon.com/it_it/resilience-hub/latest/userguide/images/MultiAccountEKS.png)

# Concessione dell' AWS Resilience Hub accesso alle risorse nel cluster Amazon EKS
<a name="grant-permissions-to-eks-in-arh"></a>

AWS Resilience Hub consente di accedere alle risorse situate nei cluster Amazon EKS a condizione che siano state configurate le autorizzazioni richieste.

**Per concedere le autorizzazioni necessarie AWS Resilience Hub per la scoperta e la valutazione delle risorse all'interno del cluster Amazon EKS**

1. Configura un ruolo IAM per accedere al cluster Amazon EKS.

   Se hai configurato l'applicazione utilizzando l'accesso basato sui ruoli, puoi saltare questo passaggio e procedere al passaggio 2 e utilizzare il ruolo che avevi usato per creare l'applicazione. Per ulteriori informazioni su come vengono AWS Resilience Hub utilizzati i ruoli IAM, consulta. [Come funziona AWS Resilience Hub con IAM](security_iam_service-with-iam.md)

   Se hai configurato la tua applicazione utilizzando le attuali autorizzazioni utente `AwsResilienceHubAssessmentEKSAccessRole` IAM, devi creare il ruolo IAM nello stesso account del cluster Amazon EKS. Questo ruolo IAM verrà quindi utilizzato durante l'accesso al cluster Amazon EKS.

   Durante l'importazione e la valutazione dell'applicazione, AWS Resilience Hub utilizza un ruolo IAM per accedere alle risorse nel cluster Amazon EKS. Questo ruolo deve essere creato nello stesso account del cluster Amazon EKS e verrà mappato con un gruppo Kubernetes che include le autorizzazioni richieste per AWS Resilience Hub valutare il cluster Amazon EKS.

   Se il tuo cluster Amazon EKS si trova nello stesso account dell'account AWS Resilience Hub chiamante, il ruolo deve essere creato utilizzando la seguente policy di fiducia IAM. In questa policy di fiducia IAM, `caller_IAM_role` viene utilizzato nell'account corrente APIs per chiamare il AWS Resilience Hub.
**Nota**  
`caller_IAM_role`È il ruolo associato al tuo account AWS utente.

   Se il tuo cluster Amazon EKS si trova in un account incrociato (un account diverso dall'account AWS Resilience Hub chiamante), devi creare il ruolo `AwsResilienceHubAssessmentEKSAccessRole` IAM utilizzando la seguente politica di fiducia IAM:
**Nota**  
Come prerequisito, per accedere al cluster Amazon EKS distribuito in un account diverso da quello dell' AWS Resilience Hub utente, devi configurare l'accesso multiaccount. Per ulteriori informazioni, consultare la pagina 

1. Crea `ClusterRole` e `ClusterRoleBinding` (o`RoleBinding`) ruoli per l'applicazione. AWS Resilience Hub 

   Stai creando `ClusterRole` e `ClusterRoleBinding` concederai le autorizzazioni di sola lettura necessarie AWS Resilience Hub per analizzare e valutare le risorse che fanno parte di determinati namespace nel tuo cluster Amazon EKS.

   AWS Resilience Hub ti consente di limitarne l'accesso ai tuoi namespace per la generazione di valutazioni di resilienza completando una delle seguenti operazioni:

   1. Concedi all'applicazione l'accesso in lettura su tutti i namespace. AWS Resilience Hub 

       AWS Resilience Hub Per valutare la resilienza delle risorse in tutti i namespace all'interno di un cluster Amazon EKS, devi creare quanto segue e. `ClusterRole` `ClusterRoleBinding`
      + `resilience-hub-eks-access-cluster-role`(`ClusterRole`) — Definisce le autorizzazioni richieste AWS Resilience Hub per valutare il tuo cluster Amazon EKS.
      +  `resilience-hub-eks-access-cluster-role-binding`(`ClusterRoleBinding`) — Definisce un gruppo denominato `resilience-hub-eks-access-group` nel cluster Amazon EKS che concede ai suoi utenti le autorizzazioni necessarie per eseguire valutazioni della resilienza. AWS Resilience Hub

      Il modello per concedere l'accesso in lettura su tutti i namespace all'applicazione è il seguente: AWS Resilience Hub 

      ```
      cat << EOF | kubectl apply -f -
      apiVersion: rbac.authorization.k8s.io/v1
      kind: ClusterRole
      metadata:
        name: resilience-hub-eks-access-cluster-role
      rules:
      - apiGroups:
          - ""
        resources:
          - pods
          - replicationcontrollers
          - nodes
        verbs:
          - get
          - list
      - apiGroups:
          - apps
        resources:
          - deployments
          - replicasets
        verbs:
          - get
          - list
      - apiGroups:
          - policy
        resources:
          - poddisruptionbudgets
        verbs:
          - get
          - list
      - apiGroups:
          - autoscaling.k8s.io
        resources:
          - verticalpodautoscalers
        verbs:
          - get
          - list
      - apiGroups:
          - autoscaling
        resources:
          - horizontalpodautoscalers
        verbs:
          - get
          - list
      - apiGroups:
          - karpenter.sh
        resources:
          - provisioners
          - nodepools
        verbs:
          - get
          - list
      - apiGroups:
          - karpenter.k8s.aws
        resources:
          - awsnodetemplates
          - ec2nodeclasses
        verbs:
          - get
          - list
      ---
      apiVersion: rbac.authorization.k8s.io/v1
      kind: ClusterRoleBinding
      metadata:
        name: resilience-hub-eks-access-cluster-role-binding
      subjects:
        - kind: Group
          name: resilience-hub-eks-access-group
          apiGroup: rbac.authorization.k8s.io
      roleRef:
        kind: ClusterRole
        name: resilience-hub-eks-access-cluster-role
        apiGroup: rbac.authorization.k8s.io
      ---
      EOF
      ```

   1. Concessione AWS Resilience Hub dell'accesso alla lettura di namespace specifici.

      È possibile limitare AWS Resilience Hub l'accesso alle risorse all'interno di un set specifico di namespace utilizzando. `RoleBinding` A tal fine, è necessario creare i seguenti ruoli:
      + `ClusterRole`— Per accedere AWS Resilience Hub alle risorse in namespace specifici all'interno di un cluster Amazon EKS e valutarne la resilienza, devi creare i seguenti ruoli. `ClusterRole`
        + `resilience-hub-eks-access-cluster-role`— Speciifica le autorizzazioni necessarie per valutare le risorse all'interno di namespace specifici.
        + `resilience-hub-eks-access-global-cluster-role`: specifica le autorizzazioni necessarie per valutare le risorse con ambito cluster, che non sono associate a uno spazio dei nomi specifico, all'interno dei cluster Amazon EKS. AWS Resilience Hub richiede le autorizzazioni per accedere a risorse con ambito cluster (come i nodi) sul cluster Amazon EKS per valutare la resilienza dell'applicazione.

        Il modello per creare il ruolo è il seguente`ClusterRole`:

        ```
        cat << EOF | kubectl apply -f -
        apiVersion: rbac.authorization.k8s.io/v1
        kind: ClusterRole
        metadata:
          name: resilience-hub-eks-access-cluster-role
        rules:
          - apiGroups:
              - ""
            resources:
              - pods
              - replicationcontrollers
            verbs:
              - get
              - list
          - apiGroups:
              - apps
            resources:
              - deployments
              - replicasets
            verbs:
              - get
              - list
          - apiGroups:
              - policy
            resources:
              - poddisruptionbudgets
            verbs:
              - get
              - list
          - apiGroups:
              - autoscaling.k8s.io
            resources:
              - verticalpodautoscalers
            verbs:
              - get
              - list
          - apiGroups:
              - autoscaling
            resources:
              - horizontalpodautoscalers
            verbs:
              - get
              - list
        
        ---
        apiVersion: rbac.authorization.k8s.io/v1
        kind: ClusterRole
        metadata:
          name: resilience-hub-eks-access-global-cluster-role
        rules:
          - apiGroups:
              - ""
            resources:
              - nodes
            verbs:
              - get
              - list
          - apiGroups:
              - karpenter.sh
            resources:
              - provisioners
              - nodepools
            verbs:
              - get
              - list
          - apiGroups:
              - karpenter.k8s.aws
            resources:
              - awsnodetemplates
              - ec2nodeclasses
            verbs:
              - get
              - list
        
        ---
        EOF
        ```
      + `RoleBinding`ruolo: questo ruolo concede le autorizzazioni necessarie per accedere alle risorse all'interno AWS Resilience Hub di namespace specifici. Cioè, è necessario creare un `RoleBinding` ruolo in ogni spazio dei nomi per consentire AWS Resilience Hub l'accesso alle risorse all'interno dello spazio dei nomi specificato. 
**Nota**  
Se si utilizza `ClusterAutoscaler` la scalabilità automatica, è necessario creare anche in. `RoleBinding` `kube-system` Questo è necessario per valutare il tuo`ClusterAutoscaler`, che fa parte del namespace. `kube-system`  
In questo modo, concederai AWS Resilience Hub le autorizzazioni necessarie per valutare le risorse all'interno del `kube-system` namespace durante la valutazione del tuo cluster Amazon EKS.

        Il modello per creare il `RoleBinding` ruolo è il seguente:

        ```
        cat << EOF | kubectl apply -f -
        apiVersion: rbac.authorization.k8s.io/v1
        kind: RoleBinding
        metadata:
          name: resilience-hub-eks-access-cluster-role-binding
          namespace: <namespace>
        subjects:
          - kind: Group
            name: resilience-hub-eks-access-group
            apiGroup: rbac.authorization.k8s.io
        roleRef:
          kind: ClusterRole
          name: resilience-hub-eks-access-cluster-role
          apiGroup: rbac.authorization.k8s.io
        
        ---
        EOF
        ```
      + `ClusterRoleBinding`ruolo: questo ruolo concede le autorizzazioni necessarie per accedere AWS Resilience Hub alle risorse con ambito cluster.

        Il modello per creare il ruolo è il seguente`ClusterRoleBinding`:

        ```
        cat << EOF | kubectl apply -f - 
        ---
        apiVersion: rbac.authorization.k8s.io/v1
        kind: ClusterRoleBinding
        metadata:
          name: resilience-hub-eks-access-global-cluster-role-binding
        subjects:
          - kind: Group
            name: resilience-hub-eks-access-group
            apiGroup: rbac.authorization.k8s.io
        roleRef:
          kind: ClusterRole
          name: resilience-hub-eks-access-global-cluster-role
          apiGroup: rbac.authorization.k8s.io
        
        ---
        EOF
        ```

1. Aggiorna il `aws-auth ConfigMap` per mappare il `resilience-hub-eks-access-group` ruolo IAM utilizzato per accedere al cluster Amazon EKS.

   Questo passaggio crea una mappatura tra il ruolo IAM utilizzato nella fase 1 e il gruppo Kubernetes creato nella fase 2. Questa mappatura concede le autorizzazioni ai ruoli IAM per l'accesso alle risorse all'interno del cluster Amazon EKS.
**Nota**  
`ROLE-NAME`si riferisce al ruolo IAM utilizzato per accedere al cluster Amazon EKS.  
Se l'applicazione è configurata per utilizzare l'accesso basato sui ruoli, il ruolo deve essere il ruolo di invoker o il ruolo di account secondario a cui viene passato AWS Resilience Hub durante la creazione dell'applicazione.
Se l'applicazione è configurata per utilizzare l'utente IAM corrente per accedere alle risorse, deve essere il. `AwsResilienceHubAssessmentEKSAccessRole`
`ACCOUNT-ID`dovrebbe essere l'ID dell' AWS account del cluster Amazon EKS.

   Puoi crearlo `aws-auth` `ConfigMap` utilizzando uno dei seguenti modi:
   + Uso di `eksctl`

     Utilizzate il seguente comando per aggiornare `aws-auth``ConfigMap`:

     ```
     eksctl create iamidentitymapping \
      --cluster <cluster-name> \
      --region=<region-code> \
      --arn arn:aws:iam::<ACCOUNT-ID>:role/<ROLE-NAME>\
      --group resilience-hub-eks-access-group \
      --username AwsResilienceHubAssessmentEKSAccessRole
     ```
   + Puoi modificare manualmente `aws-auth` `ConfigMap` aggiungendo i dettagli del ruolo IAM alla `mapRoles` `ConfigMap` sezione dei dati sottostanti. Usa il seguente comando per modificare il `aws-auth``ConfigMap`.

     `kubectl edit -n kube-system configmap/aws-auth`

     `mapRoles`la sezione è composta dai seguenti parametri:
     + `rolearn`— L'[Amazon Resource Name (ARN)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) del ruolo IAM da aggiungere. 
       + Sintassi ARN —. `arn:aws:iam::<ACCOUNT-ID>:role/<ROLE-NAME>`
     + `username`— Il nome utente all'interno di Kubernetes da mappare al ruolo IAM (). `AwsResilienceHubAssessmentEKSAccessRole`
     + `groups`— I nomi dei gruppi devono corrispondere ai nomi dei gruppi creati nella **Fase** 2 (). `resilience-hub-eks-access-group`
**Nota**  
Se la `mapRoles` sezione non esiste, è necessario aggiungerla manualmente.

     Utilizza il seguente modello per aggiungere i dettagli del ruolo IAM alla `mapRoles` `ConfigMap` sezione dei dati sottostanti.

     ```
         - groups:
           - resilience-hub-eks-access-group
           rolearn: arn:aws:iam::<ACCOUNT-ID>:role/<ROLE-NAME>
           username: AwsResilienceHubAssessmentEKSAccessRole
     ```