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

# Sicurezza e operatore Spark con Amazon EMR su EKS
<a name="spark-operator-security"></a>

Esistono due modi per configurare le autorizzazioni di accesso al cluster quando si utilizza l'operatore Spark. Il primo consiste nell'utilizzare il controllo degli accessi basato sui ruoli, il controllo degli accessi basato sui ruoli (RBAC) limita l'accesso in base al ruolo di una persona all'interno di un'organizzazione. È diventato il modo principale per gestire l'accesso. Il secondo metodo di accesso consiste nell'assumere un AWS Identity and Access Management ruolo, che fornisce l'accesso alle risorse mediante autorizzazioni specifiche assegnate.

**Topics**
+ [Configurazione delle autorizzazioni di accesso al cluster con controllo degli accessi basato sui ruoli (role-based access control, RBAC)](spark-operator-security-rbac.md)
+ [Configurazione delle autorizzazioni di accesso al cluster con ruoli IAM per gli account di servizio (IAM roles for service account, IRSA)](spark-operator-security-irsa.md)

# Configurazione delle autorizzazioni di accesso al cluster con controllo degli accessi basato sui ruoli (role-based access control, RBAC)
<a name="spark-operator-security-rbac"></a>

Per implementare l'operatore Spark, Amazon EMR su EKS crea due ruoli e account di servizio per l'operatore Spark e le app Spark.

**Topics**
+ [Account e ruolo di servizio dell'operatore](#spark-operator-sa-oper)
+ [Account e ruolo di servizio Spark](#spark-operator-sa-spark)

## Account e ruolo di servizio dell'operatore
<a name="spark-operator-sa-oper"></a>

Amazon EMR su EKS crea l'**account e il ruolo di servizio dell'operatore** per gestire `SparkApplications` per i lavori Spark e per altre risorse come i servizi.

Il nome predefinito per questo account di servizio è `emr-containers-sa-spark-operator`.

Per questo ruolo di servizio vigono le regole elencate di seguito: 

```
 rules:
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - services
  - configmaps
  - secrets
  verbs:
  - create
  - get
  - delete
  - update
- apiGroups:
  - extensions
  - networking.k8s.io
  resources:
  - ingresses
  verbs:
  - create
  - get
  - delete
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - get
- apiGroups:
  - ""
  resources:
  - events
  verbs:
  - create
  - update
  - patch
- apiGroups:
  - ""
  resources:
  - resourcequotas
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - apiextensions.k8s.io
  resources:
  - customresourcedefinitions
  verbs:
  - create
  - get
  - update
  - delete
- apiGroups:
  - admissionregistration.k8s.io
  resources:
  - mutatingwebhookconfigurations
  - validatingwebhookconfigurations
  verbs:
  - create
  - get
  - update
  - delete
- apiGroups:
  - sparkoperator.k8s.io
  resources:
  - sparkapplications
  - sparkapplications/status
  - scheduledsparkapplications
  - scheduledsparkapplications/status
  verbs:
  - "*"
  {{- if .Values.batchScheduler.enable }}
  # required for the `volcano` batch scheduler
- apiGroups:
  - scheduling.incubator.k8s.io
  - scheduling.sigs.dev
  - scheduling.volcano.sh
  resources:
  - podgroups
  verbs:
  - "*"
  {{- end }}
  {{ if .Values.webhook.enable }}
- apiGroups:
  - batch
  resources:
  - jobs
  verbs:
  - delete
  {{- end }}
```

## Account e ruolo di servizio Spark
<a name="spark-operator-sa-spark"></a>

Un pod del driver Spark necessita di un account di servizio Kubernetes nello stesso spazio dei nomi del pod. Questo account di servizio necessita delle autorizzazioni per creare, ottenere, elencare, applicare patch ai ed eliminare i pod dell'executor e per creare un servizio headless Kubernetes per il driver. Il driver si interrompe e si chiude senza l'account di servizio a meno che l'account di servizio predefinito nello spazio dei nomi del pod disponga delle autorizzazioni richieste.

Il nome predefinito per questo account di servizio è `emr-containers-sa-spark`.

Per questo ruolo di servizio vigono le regole elencate di seguito: 

```
 rules:
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - services
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - configmaps
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - persistentvolumeclaims
  verbs:
  - "*"
```

# Configurazione delle autorizzazioni di accesso al cluster con ruoli IAM per gli account di servizio (IAM roles for service account, IRSA)
<a name="spark-operator-security-irsa"></a>

Questa sezione utilizza un esempio per dimostrare come configurare un account di servizio Kubernetes per assumere un ruolo. AWS Identity and Access Management I pod che utilizzano l'account di servizio possono quindi accedere a qualsiasi AWS servizio a cui il ruolo dispone delle autorizzazioni per accedere.

L'esempio seguente esegue un'applicazione Spark per contare le parole da un file in Amazon S3. A tale scopo, puoi configurare i ruoli IAM per gli account di servizio (IRSA) in modo da autenticare e autorizzare gli account di servizio Kubernetes.

**Nota**  
Questo esempio utilizza lo spazio dei nomi "spark-operator" per l'operatore Spark e per lo spazio dei nomi in cui invii l'applicazione Spark.

## Prerequisiti
<a name="spark-operator-security-irsa-prereqs"></a>

Prima di provare l'esempio in questa pagina, completa i prerequisiti descritti di seguito:
+ [Esegui la configurazione per l'operatore Spark]().
+ [Installazione dell'operatore Spark](spark-operator-gs.md#spark-operator-install).
+ [Crea un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html).
+ Salva la tua poesia preferita in un file di testo denominato `poem.txt` e carica il file nel bucket S3. L'applicazione Spark che crei in questa pagina leggerà il contenuto del file di testo. Per ulteriori informazioni, consulta [Carica un oggetto nel tuo bucket S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) nella *Guida per l'utente di Amazon Simple Storage Service*.

## Configurazione di un account di servizio Kubernetes per l'assunzione di un ruolo IAM
<a name="spark-operator-security-irsa-config"></a>

Utilizza i seguenti passaggi per configurare un account di servizio Kubernetes in modo che assuma un ruolo IAM che i pod possono utilizzare per accedere ai AWS servizi a cui il ruolo dispone delle autorizzazioni di accesso.

1. Dopo aver completato il[Prerequisiti](#spark-operator-security-irsa-prereqs), usa AWS Command Line Interface per creare un `example-policy.json` file che consenta l'accesso in sola lettura al file che hai caricato su Amazon S3:

   ```
   cat >example-policy.json <<EOF
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::my-pod-bucket",
                   "arn:aws:s3:::my-pod-bucket/*"
               ]
           }
       ]
   }
   EOF
   ```

1. Successivamente, crea una policy IAM `example-policy`:

   ```
   aws iam create-policy --policy-name example-policy --policy-document file://example-policy.json
   ```

1. Quindi, crea un ruolo IAM `example-role` e associalo a un account di servizio Kubernetes per il driver Spark:

   ```
   eksctl create iamserviceaccount --name driver-account-sa --namespace spark-operator \
   --cluster my-cluster --role-name "example-role" \
   --attach-policy-arn arn:aws:iam::111122223333:policy/example-policy --approve
   ```

1. Crea un file yaml con le associazioni di ruoli del cluster necessarie per l'account di servizio del driver Spark:

   ```
   cat >spark-rbac.yaml <<EOF
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: driver-account-sa
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: spark-role
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: edit
   subjects:
     - kind: ServiceAccount
       name: driver-account-sa
       namespace: spark-operator
   EOF
   ```

1. Applica le configurazioni delle associazioni di ruoli del cluster:

   ```
   kubectl apply -f spark-rbac.yaml
   ```

Il comando kubectl dovrebbe confermare la corretta creazione dell'account:

```
serviceaccount/driver-account-sa created
clusterrolebinding.rbac.authorization.k8s.io/spark-role configured
```

## Esecuzione di un'applicazione dall'operatore Spark
<a name="spark-operator-security-irsa-run"></a>

Dopo aver [configurato l'account di servizio Kubernetes](), puoi eseguire un'applicazione Spark che conti il numero di parole nel file di testo che hai caricato come parte di [Prerequisiti](#spark-operator-security-irsa-prereqs).

1. Crea un nuovo file`word-count.yaml`, con una `SparkApplication` definizione per la tua applicazione di conteggio parole, basato sulla versione 6 di Amazon EMR.

   ```
   cat >word-count.yaml <<EOF
   apiVersion: "sparkoperator.k8s.io/v1beta2"
   kind: SparkApplication
   metadata:
     name: word-count
     namespace: spark-operator
   spec:
     type: Java
     mode: cluster
     image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.10.0:latest"
     imagePullPolicy: Always
     mainClass: org.apache.spark.examples.JavaWordCount
     mainApplicationFile: local:///usr/lib/spark/examples/jars/spark-examples.jar
     arguments:
       - s3://my-pod-bucket/poem.txt
     hadoopConf:
      # EMRFS filesystem
       fs.s3.customAWSCredentialsProvider: com.amazonaws.auth.WebIdentityTokenCredentialsProvider
       fs.s3.impl: com.amazon.ws.emr.hadoop.fs.EmrFileSystem
       fs.AbstractFileSystem.s3.impl: org.apache.hadoop.fs.s3.EMRFSDelegate
       fs.s3.buffer.dir: /mnt/s3
       fs.s3.getObject.initialSocketTimeoutMilliseconds: "2000"
       mapreduce.fileoutputcommitter.algorithm.version.emr_internal_use_only.EmrFileSystem: "2"
       mapreduce.fileoutputcommitter.cleanup-failures.ignored.emr_internal_use_only.EmrFileSystem: "true"
     sparkConf:
       # Required for EMR Runtime
       spark.driver.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.driver.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
       spark.executor.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.executor.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
     sparkVersion: "3.3.1"
     restartPolicy:
       type: Never
     driver:
       cores: 1
       coreLimit: "1200m"
       memory: "512m"
       labels:
         version: 3.3.1
       serviceAccount: my-spark-driver-sa
     executor:
       cores: 1
       instances: 1
       memory: "512m"
       labels:
         version: 3.3.1
   EOF
   ```

   Se utilizzi l'operatore spark con una versione 7, modifichi alcuni valori di configurazione:

   ```
   cat >word-count.yaml <<EOF
   apiVersion: "sparkoperator.k8s.io/v1beta2"
   kind: SparkApplication
   metadata:
     name: word-count
     namespace: spark-operator
   spec:
     type: Java
     mode: cluster
     image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-7.7.0:latest"
     imagePullPolicy: Always
     mainClass: org.apache.spark.examples.JavaWordCount
     mainApplicationFile: local:///usr/lib/spark/examples/jars/spark-examples.jar
     arguments:
       - s3://my-pod-bucket/poem.txt
     hadoopConf:
      # EMRFS filesystem
       fs.s3.customAWSCredentialsProvider: com.amazonaws.auth.WebIdentityTokenCredentialsProvider
       fs.s3.impl: com.amazon.ws.emr.hadoop.fs.EmrFileSystem
       fs.AbstractFileSystem.s3.impl: org.apache.hadoop.fs.s3.EMRFSDelegate
       fs.s3.buffer.dir: /mnt/s3
       fs.s3.getObject.initialSocketTimeoutMilliseconds: "2000"
       mapreduce.fileoutputcommitter.algorithm.version.emr_internal_use_only.EmrFileSystem: "2"
       mapreduce.fileoutputcommitter.cleanup-failures.ignored.emr_internal_use_only.EmrFileSystem: "true"
     sparkConf:
       # Required for EMR Runtime
       spark.driver.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/aws-java-sdk-v2/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.driver.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
       spark.executor.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/aws-java-sdk-v2/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.executor.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
     sparkVersion: "3.3.1"
     restartPolicy:
       type: Never
     driver:
       cores: 1
       coreLimit: "1200m"
       memory: "512m"
       labels:
         version: 3.3.1
       serviceAccount: my-spark-driver-sa
     executor:
       cores: 1
       instances: 1
       memory: "512m"
       labels:
         version: 3.3.1
   EOF
   ```

1. Invia l'applicazione Spark.

   ```
   kubectl apply -f word-count.yaml
   ```

   Il comando kubectl dovrebbe restituire la conferma che hai creato correttamente un oggetto `SparkApplication` denominato `word-count`.

   ```
   sparkapplication.sparkoperator.k8s.io/word-count configured
   ```

1. Per controllare gli eventi dell'oggetto `SparkApplication`, esegui il comando seguente:

   ```
   kubectl describe sparkapplication word-count -n spark-operator
   ```

   Il comando kubectl dovrebbe restituire la descrizione di `SparkApplication` con gli eventi:

   ```
   Events:
     Type     Reason                               Age                    From            Message
     ----     ------                               ----                   ----            -------
     Normal   SparkApplicationSpecUpdateProcessed  3m2s (x2 over 17h)     spark-operator  Successfully processed spec update for SparkApplication word-count
     Warning  SparkApplicationPendingRerun         3m2s (x2 over 17h)     spark-operator  SparkApplication word-count is pending rerun
     Normal   SparkApplicationSubmitted            2m58s (x2 over 17h)    spark-operator  SparkApplication word-count was submitted successfully
     Normal   SparkDriverRunning                   2m56s (x2 over 17h)    spark-operator  Driver word-count-driver is running
     Normal   SparkExecutorPending                 2m50s                  spark-operator  Executor [javawordcount-fdd1698807392c66-exec-1] is pending
     Normal   SparkExecutorRunning                 2m48s                  spark-operator  Executor [javawordcount-fdd1698807392c66-exec-1] is running
     Normal   SparkDriverCompleted                 2m31s (x2 over 17h)    spark-operator  Driver word-count-driver completed
     Normal   SparkApplicationCompleted            2m31s (x2 over 17h)    spark-operator  SparkApplication word-count completed
     Normal   SparkExecutorCompleted               2m31s (x2 over 2m31s)  spark-operator  Executor [javawordcount-fdd1698807392c66-exec-1] completed
   ```

Ora l'applicazione sta contando le parole nel tuo file S3. Per trovare il numero di parole, fai riferimento ai file di log del driver:

```
kubectl logs pod/word-count-driver -n spark-operator
```

Il comando kubectl dovrebbe restituire il contenuto del file di log con i risultati dell'applicazione di conteggio parole.

```
INFO DAGScheduler: Job 0 finished: collect at JavaWordCount.java:53, took 5.146519 s
                Software: 1
```

[Per maggiori informazioni su come inviare le applicazioni a Spark tramite l'operatore Spark, consulta Using a SparkApplication nella documentazione di *Kubernetes Operator for Apache Spark (8s-operator*) su.](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/) spark-on-k GitHub