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

# Tutorial: Connect da un'applicazione containerizzata ospitata su Amazon Elastic Kubernetes Service
<a name="EKS-tutorial"></a>

Questo tutorial illustra i passaggi necessari per configurare un cluster Amazon Elastic Kubernetes Service (Amazon EKS) per ospitare un'applicazione containerizzata che si connette ad Amazon Keyspaces utilizzando l'autenticazione SigV4.

Amazon EKS è un servizio gestito che elimina la necessità di installare, utilizzare e mantenere il proprio piano di controllo Kubernetes. [Kubernetes](https://kubernetes.io/docs/concepts/overview/) è un sistema open source che consente di automatizzare la gestione, il dimensionamento e l'implementazione di applicazioni distribuite in container.

Il tutorial fornisce step-by-step indicazioni per configurare, creare e distribuire un'applicazione Java containerizzata su Amazon EKS. Nell'ultimo passaggio esegui l'applicazione per scrivere dati su una tabella Amazon Keyspaces.

**Topics**
+ [Prerequisiti per la connessione da Amazon EKS ad Amazon Keyspaces](EKS-tutorial-prerequisites.md)
+ [Fase 1: configurare il cluster Amazon EKS e configurare le autorizzazioni IAM](EKS-tutorial-step1.md)
+ [Passaggio 2: configura l'applicazione](EKS-tutorial-step2.md)
+ [Passaggio 3: crea l'immagine dell'applicazione e carica il file Docker nel tuo repository Amazon ECR](EKS-tutorial-step3.md)
+ [Fase 4: distribuire l'applicazione su Amazon EKS e scrivere dati nella tabella](EKS-tutorial-step4.md)
+ [Fase 5: Pulizia (facoltativa)](EKS-tutorial-step5.md)

# Prerequisiti per la connessione da Amazon EKS ad Amazon Keyspaces
<a name="EKS-tutorial-prerequisites"></a>

**Crea le seguenti AWS risorse prima di iniziare con il tutorial**

1. Prima di iniziare questo tutorial, segui le istruzioni di AWS configurazione contenute in[Accesso ad Amazon Keyspaces (per Apache Cassandra)](accessing.md). Questi passaggi includono la registrazione AWS e la creazione di un principale AWS Identity and Access Management (IAM) con accesso ad Amazon Keyspaces. 

1. Crea uno spazio di chiavi Amazon Keyspaces con il nome `aws` e una tabella con il nome su `user` cui scrivere dall'applicazione containerizzata in esecuzione in Amazon EKS più avanti in questo tutorial. Puoi farlo con o utilizzando. AWS CLI `cqlsh`

------
#### [ AWS CLI ]

   ```
   aws keyspaces create-keyspace --keyspace-name 'aws'
   ```

   Per confermare che il keyspace è stato creato, puoi usare il seguente comando.

   ```
   aws keyspaces list-keyspaces
   ```

   Per creare la tabella, puoi usare il seguente comando.

   ```
   aws keyspaces create-table --keyspace-name 'aws' --table-name 'user' --schema-definition 'allColumns=[
               {name=username,type=text}, {name=fname,type=text},{name=last_update_date,type=timestamp},{name=lname,type=text}],
               partitionKeys=[{name=username}]'
   ```

   Per confermare che la tabella è stata creata, è possibile utilizzare il seguente comando.

   ```
   aws keyspaces list-tables --keyspace-name 'aws'
   ```

   Per ulteriori informazioni, consulta [creare keyspace](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-keyspace.html) e [creare tabella](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-table.html) nel *AWS CLI Command Reference.*

------
#### [ cqlsh ]

   ```
   CREATE KEYSPACE aws WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'}  AND durable_writes = true;
   CREATE TABLE aws.user (
       username text PRIMARY KEY,
       fname text,
       last_update_date timestamp,
       lname text
   );
   ```

   Per verificare che la tabella sia stata creata, è possibile utilizzare la seguente dichiarazione.

   ```
   SELECT * FROM system_schema.tables WHERE keyspace_name = "aws";
   ```

   La tua tabella dovrebbe essere elencata nell'output di questa dichiarazione. Nota che può esserci un ritardo nella creazione della tabella. Per ulteriori informazioni, consulta [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create).

------

1. Crea un cluster Amazon EKS con un tipo di nodo **Fargate - Linux**. Fargate è un motore di elaborazione serverless che consente di distribuire Kubernetes Pods senza gestire istanze Amazon Amazon EC2. Per seguire questo tutorial senza dover aggiornare il nome del cluster in tutti i comandi di esempio, crea un cluster con lo stesso nome `my-eks-cluster` seguendo le istruzioni in [Getting started with Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html), `eksctl` nella *Amazon EKS User Guide*. Una volta creato il cluster, verifica che i nodi e i due Pod predefiniti siano funzionanti e integri. Puoi farlo con il seguente comando.

   ```
   kubectl get pods -A -o wide
   ```

   Dovresti vedere qualcosa di simile a questo risultato.

   ```
   NAMESPACE     NAME                       READY   STATUS    RESTARTS   AGE   IP          NODE                                                NOMINATED NODE   READINESS GATES
   kube-system   coredns-1234567890-abcde   1/1     Running   0          18m   192.0.2.0   fargate-ip-192-0-2-0.region-code.compute.internal   <none>           <none>
   kube-system   coredns-1234567890-12345   1/1     Running   0          18m   192.0.2.1   fargate-ip-192-0-2-1.region-code.compute.internal   <none>           <none>
   ```

1. Installazione di Docker. Per istruzioni su come installare Docker su un'istanza Amazon EC2, [consulta Install](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#getting-started-cli-prereqs) Docker nella Amazon Elastic Container Registry User Guide. 

   Docker è disponibile per diversi sistemi operativi, compresa la maggior parte delle distribuzioni Linux, ad esempio Ubuntu, e persino per macOS e Windows. Per ulteriori informazioni sull'installazione di Docker sul tuo specifico sistema operativo, consulta la [guida all'installazione di Docker](https://docs.docker.com/engine/install/#installation). 

1. Crea un repository Amazon ECR. Amazon ECR è un servizio di registro delle immagini dei container AWS gestito che puoi utilizzare con la tua CLI preferita per inviare, estrarre e gestire immagini Docker. Per ulteriori informazioni sui repository Amazon ECR, consulta la [Amazon Elastic Container Registry User Guide](https://docs.aws.amazon.com/AmazonECR/latest/userguide/). Puoi utilizzare il seguente comando per creare un repository con il nome. `my-ecr-repository`

   ```
   aws ecr create-repository --repository-name my-ecr-repository
   ```

Dopo aver completato i passaggi preliminari, procedere a. [Fase 1: configurare il cluster Amazon EKS e configurare le autorizzazioni IAM](EKS-tutorial-step1.md)

# Fase 1: configurare il cluster Amazon EKS e configurare le autorizzazioni IAM
<a name="EKS-tutorial-step1"></a>

**Configura il cluster Amazon EKS e crea le risorse IAM necessarie per consentire a un account di servizio Amazon EKS di connettersi alla tabella Amazon Keyspaces**

1. Crea un provider Open ID Connect (OIDC) per il cluster Amazon EKS. Ciò è necessario per utilizzare i ruoli IAM per gli account di servizio. Per ulteriori informazioni sui provider OIDC e su come crearli, consulta [Creating an IAM OIDC provider for your cluster nella](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) *Amazon* EKS User Guide.

   1. Creare un provider di identità OIDC IAM per il cluster con il comando seguente. Questo esempio presuppone che il nome del cluster sia. `my-eks-cluster` Se hai un cluster con un nome diverso, ricordati di aggiornare il nome in tutti i comandi futuri.

      ```
      eksctl utils associate-iam-oidc-provider --cluster my-eks-cluster --approve 
      ```

   1. Conferma che il provider di identità OIDC sia stato registrato con IAM con il seguente comando.

      ```
      aws iam list-open-id-connect-providers --region us-east-1
      ```

      L'output dovrebbe essere simile a questo. Prendi nota dell'Amazon Resource Name (ARN) dell'OIDC, ne avrai bisogno nella fase successiva quando crei una policy di fiducia per l'account di servizio.

      ```
      {
          "OpenIDConnectProviderList": [
              ..
              {
                  "Arn": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
              }
          ]
      }
      ```

1. Crea un account di servizio per il cluster Amazon EKS. Gli account di servizio forniscono un'identità per i processi eseguiti in un *Pod*. Un Pod è l'oggetto Kubernetes più piccolo e semplice che puoi utilizzare per distribuire un'applicazione containerizzata. Successivamente, crea un ruolo IAM che l'account di servizio possa assumere per ottenere le autorizzazioni per le risorse. Puoi accedere a qualsiasi AWS servizio da un Pod che è stato configurato per utilizzare un account di servizio che può assumere un ruolo IAM con autorizzazioni di accesso a quel servizio.

   1. Crea un nuovo spazio dei nomi per l'account del servizio. Un namespace aiuta a isolare le risorse del cluster create per questo tutorial. È possibile creare un nuovo spazio dei nomi utilizzando il seguente comando.

      ```
      kubectl create namespace my-eks-namespace
      ```

   1. Per utilizzare uno spazio dei nomi personalizzato, è necessario associarlo a un profilo Fargate. Il codice seguente ne è un esempio.

      ```
      eksctl create fargateprofile \
          --cluster my-eks-cluster \
          --name my-fargate-profile \
          --namespace my-eks-namespace \
          --labels *=*
      ```

   1. Crea un account di servizio con il nome `my-eks-serviceaccount` nello spazio dei nomi `my-eks-namespace` per il tuo cluster Amazon EKS utilizzando il seguente comando.

      ```
      cat >my-serviceaccount.yaml <<EOF
      apiVersion: v1
      kind: ServiceAccount
      metadata:
        name: my-eks-serviceaccount
        namespace: my-eks-namespace
      EOF
      kubectl apply -f my-serviceaccount.yaml
      ```

   1. Esegui il comando seguente per creare un file di policy di fiducia che indichi al ruolo IAM di considerare attendibile il tuo account di servizio. Questa relazione di fiducia è necessaria prima che un preside possa assumere un ruolo. È necessario apportare le seguenti modifiche al file:
      + Per la`Principal`, inserisci l'ARN che IAM ha restituito al `list-open-id-connect-providers` comando. L'ARN contiene il numero di conto e la regione.
      + Nella `condition` dichiarazione, sostituisci l'id Regione AWS e l'ID OIDC.
      + Verificate che il nome e lo spazio dei nomi dell'account del servizio siano corretti.

      È necessario allegare il file delle policy di fiducia nel passaggio successivo quando si crea il ruolo IAM.

      ```
      cat >trust-relationship.json <<EOF
      {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
                  },
                  "Action": "sts:AssumeRoleWithWebIdentity",
                  "Condition": {
                      "StringEquals": {
                          "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:my-eks-namespace:my-eks-serviceaccount",
                          "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
                      }
                  }
              }
          ]
      }
      EOF
      ```

      Facoltativo: puoi anche aggiungere più voci nelle `StringLike` condizioni `StringEquals` or per consentire a più account di servizio o namespace di assumere il ruolo. Per consentire al tuo account di servizio di assumere un ruolo IAM in un altro AWS account, consulta [Autorizzazioni IAM per più account](https://docs.aws.amazon.com/eks/latest/userguide/cross-account-access.html) nella *Amazon EKS User Guide*.

1. Crea un ruolo IAM con il nome da assumere `my-iam-role` per l'account del servizio Amazon EKS. Allega al ruolo il file di policy di fiducia creato nell'ultimo passaggio. La policy di fiducia specifica l'account di servizio e il provider OIDC di cui il ruolo IAM può fidarsi. 

   ```
   aws iam create-role --role-name my-iam-role --assume-role-policy-document file://trust-relationship.json --description "EKS service account role"
   ```

1. Assegna le autorizzazioni del ruolo IAM ad Amazon Keyspaces allegando una policy di accesso. 

   1. Allega una policy di accesso per definire le azioni che il ruolo IAM può eseguire su risorse Amazon Keyspaces specifiche. Per questo tutorial utilizziamo la policy AWS gestita`AmazonKeyspacesFullAccess`, perché la nostra applicazione scriverà dati nella tua tabella Amazon Keyspaces. Come best practice, tuttavia, si consiglia di creare politiche di accesso personalizzate che implementino il principio dei privilegi minimi. Per ulteriori informazioni, consulta [Come funziona Amazon Keyspaces con IAM](security_iam_service-with-iam.md).

      ```
      aws iam attach-role-policy --role-name my-iam-role --policy-arn=arn:aws:iam::aws:policy/AmazonKeyspacesFullAccess
      ```

      Conferma che la policy è stata associata correttamente al ruolo IAM con la seguente dichiarazione.

      ```
      aws iam list-attached-role-policies --role-name my-iam-role
      ```

      L'output dovrebbe essere simile a questo.

      ```
      {
          "AttachedPolicies": [
              {
                  "PolicyName": "AmazonKeyspacesFullAccess",
                  "PolicyArn": "arn:aws:iam::aws:policy/AmazonKeyspacesFullAccess"
              }
          ]
      }
      ```

   1. Annota l'account del servizio con l'Amazon Resource Name (ARN) del ruolo IAM che può assumere. Assicurati di aggiornare l'ARN del ruolo con l'ID del tuo account.

      ```
      kubectl annotate serviceaccount -n my-eks-namespace my-eks-serviceaccount eks.amazonaws.com/role-arn=arn:aws:iam::111122223333:role/my-iam-role
      ```

1. Verifica che il ruolo IAM e l'account di servizio siano configurati correttamente.

   1. Verifica che la policy di fiducia del ruolo IAM sia configurata correttamente con la seguente dichiarazione.

      ```
      aws iam get-role --role-name my-iam-role --query Role.AssumeRolePolicyDocument
      ```

      L'output dovrebbe essere simile a questo.

      ```
      {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
                  },
                  "Action": "sts:AssumeRoleWithWebIdentity",
                  "Condition": {
                      "StringEquals": {
                          "oidc.eks.us-east-1/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com",
                          "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:my-eks-namespace:my-eks-serviceaccount"
                      }
                  }
              }
          ]
      }
      ```

   1. Verifica che l'account del servizio Amazon EKS sia annotato con il ruolo IAM.

      ```
      kubectl describe serviceaccount my-eks-serviceaccount -n my-eks-namespace
      ```

      L'output dovrebbe essere simile a questo.

      ```
      Name: my-eks-serviceaccount 
      Namespace:my-eks-namespace
      Labels: <none>
      Annotations: eks.amazonaws.com/role-arn: arn:aws:iam::111122223333:role/my-iam-role 
      Image pull secrets: <none> 
      Mountable secrets: <none> 
      Tokens: <none> 
      [...]
      ```

Dopo aver creato l'account di servizio Amazon EKS, il ruolo IAM e configurato le relazioni e le autorizzazioni richieste, procedi [Passaggio 2: configura l'applicazione](EKS-tutorial-step2.md) con.

# Passaggio 2: configura l'applicazione
<a name="EKS-tutorial-step2"></a>

In questa fase crei la tua applicazione che si connette ad Amazon Keyspaces utilizzando il plug-in SigV4. [Puoi visualizzare e scaricare l'applicazione Java di esempio dal repository di codice di esempio Amazon Keyspaces su Github.](https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/eks) Oppure puoi continuare utilizzando la tua applicazione, assicurandoti di completare tutti i passaggi di configurazione.

**Configura la tua applicazione e aggiungi le dipendenze richieste.**

1. È possibile scaricare l'applicazione Java di esempio clonando il repository Github utilizzando il seguente comando.

   ```
   git clone https://github.com/aws-samples/amazon-keyspaces-examples.git
   ```

1. Dopo aver scaricato il repository Github, decomprimi il file scaricato e vai alla directory del file. `resources` `application.conf`

   1. **Configurazione dell'applicazione**

      In questo passaggio si configura il plugin di autenticazione SigV4. È possibile utilizzare il seguente esempio nella propria applicazione. Se non l'avete già fatto, dovete generare le vostre chiavi di accesso IAM (un ID di chiave di accesso e una chiave di accesso segreta) e salvarle nel file di AWS configurazione o come variabili di ambiente. Per istruzioni dettagliate, vedi [Credenziali richieste dal AWS CLI, dall' AWS SDK o dal plug-in Amazon Keyspaces SigV4 per i driver client Cassandra](SigV4_credentials.md). Aggiorna la AWS regione e l'endpoint di servizio per Amazon Keyspaces secondo necessità. Per ulteriori endpoint di servizio, consulta. [Endpoint di servizio per Amazon Keyspaces](programmatic.endpoints.md) Sostituisci la posizione del truststore, il nome del truststore e la password del truststore con i tuoi.

      ```
      datastax-java-driver {
        basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"]
        basic.load-balancing-policy.local-datacenter = "us-east-1"
        advanced.auth-provider {
          class = software.aws.mcs.auth.SigV4AuthProvider
          aws-region = "us-east-1"
        }
        advanced.ssl-engine-factory {
          class = DefaultSslEngineFactory
          truststore-path = "truststore_locationtruststore_name.jks"
          truststore-password = "truststore_password;"
        }
      }
      ```

   1. **Aggiungi la dipendenza del modulo STS.**

      Ciò aggiunge la possibilità di utilizzare un `WebIdentityTokenCredentialsProvider` che restituisce le AWS credenziali che l'applicazione deve fornire in modo che l'account del servizio possa assumere il ruolo IAM. È possibile eseguire questa operazione in base all'esempio seguente.

      ```
              <dependency>
                  <groupId>com.amazonaws</groupId>
                  <artifactId>aws-java-sdk-sts</artifactId>
                  <version>1.11.717</version> 
              </dependency>
      ```

   1. **Aggiungi la dipendenza SigV4.**

       Questo pacchetto implementa il plug-in di autenticazione SigV4 necessario per l'autenticazione su Amazon Keyspaces.

      ```
              <dependency>
                  <groupId>software.aws.mcs</groupId>
                  <artifactId>aws-sigv4-auth-cassandra-java-driver-plugin</artifactId>
                  <version>4.0.3</version> 
              </dependency>
      ```

1. **Aggiungi una dipendenza per la registrazione.**

    Senza registri, la risoluzione dei problemi di connessione è impossibile. In questo tutorial, utilizziamo `slf4j` come framework di registrazione e lo utilizziamo `logback.xml` per memorizzare l'output del registro. Abbiamo impostato il livello di registrazione su per `debug` stabilire la connessione. È possibile utilizzare l'esempio seguente per aggiungere la dipendenza.

   ```
           <dependency>
               <groupId>org.slf4j</groupId>
               <artifactId>slf4j-api</artifactId>
               <version>2.0.5</version> 
           </dependency>
   ```

   È possibile utilizzare il seguente frammento di codice per configurare la registrazione.

   ```
   <configuration>
       <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
           
           <encoder>
               <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
           </encoder>
       </appender>
   
       <root level="debug">
           <appender-ref ref="STDOUT" />
       </rootv
   </configuration>
   ```
**Nota**  
Il `debug` livello è necessario per esaminare gli errori di connessione. Dopo esserti connesso correttamente ad Amazon Keyspaces dalla tua applicazione, puoi modificare il livello di registrazione in base alle `info` tue esigenze. `warning` 

# Passaggio 3: crea l'immagine dell'applicazione e carica il file Docker nel tuo repository Amazon ECR
<a name="EKS-tutorial-step3"></a>

In questo passaggio, compila l'applicazione di esempio, crea un'immagine Docker e invia l'immagine al tuo repository Amazon ECR.

**Crea la tua applicazione, crea un'immagine Docker e inviala ad Amazon Elastic Container Registry**

1. Imposta le variabili di ambiente per la build che definisce la tua Regione AWS. Sostituisci le regioni negli esempi con le tue.

   ```
   export CASSANDRA_HOST=cassandra.us-east-1.amazonaws.com:9142
   export CASSANDRA_DC=us-east-1
   ```

1. Compila la tua applicazione con Apache Maven versione 3.6.3 o successiva usando il seguente comando.

   ```
   mvn clean install
   ```

   Questo crea un `JAR` file con tutte le dipendenze incluse nella directory. `target`

1. Recupera l'URI del repository ECR necessario per il passaggio successivo con il seguente comando. Assicurati di aggiornare la regione con quella che hai utilizzato.

   ```
   aws ecr describe-repositories --region us-east-1
   ```

   L'output dovrebbe essere simile a quello dell'esempio seguente.

   ```
   "repositories": [
    {
    "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/my-ecr-repository",
    "registryId": "111122223333",
    "repositoryName": "my-ecr-repository",
    "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository",
    "createdAt": "2023-11-02T03:46:34+00:00",
    "imageTagMutability": "MUTABLE",
    "imageScanningConfiguration": {
    "scanOnPush": false
    },
    "encryptionConfiguration": {
    "encryptionType": "AES256"
    }
    },
   ```

1. Dalla directory principale dell'applicazione, crea l'immagine Docker utilizzando l'URI del repository dell'ultimo passaggio. Modifica il file Docker secondo necessità. Nel comando build, assicurati di sostituire l'ID dell'account e di Regione AWS impostarlo sulla regione in cui si trova il repository `my-ecr-repository` Amazon ECR. 

   ```
   docker build -t 111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository:latest .
   ```

1. Recupera un token di autenticazione per inviare l'immagine Docker ad Amazon ECR. Puoi farlo con il seguente comando.

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
   ```

1. Innanzitutto, verifica la presenza di immagini esistenti nel tuo repository Amazon ECR. Utilizzare il seguente comando.

   ```
   aws ecr describe-images --repository-name my-ecr-repository --region us-east-1
   ```

   Quindi, invia l'immagine Docker al repository. Utilizzare il seguente comando.

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository:latest
   ```

# Fase 4: distribuire l'applicazione su Amazon EKS e scrivere dati nella tabella
<a name="EKS-tutorial-step4"></a>

In questa fase del tutorial, configuri la distribuzione di Amazon EKS per la tua applicazione e confermi che l'applicazione è in esecuzione e può connettersi ad Amazon Keyspaces.

Per distribuire un'applicazione su Amazon EKS, devi configurare tutte le impostazioni pertinenti in un file chiamato`deployment.yaml`. Questo file viene quindi utilizzato da Amazon EKS per distribuire l'applicazione. I metadati del file devono contenere le seguenti informazioni:
+ **Nome dell'applicazione**: il nome dell'applicazione. Per questo tutorial, usiamo`my-keyspaces-app`.
+ Namespace **Kubernetes, lo spazio dei nomi** del cluster Amazon EKS. Per questo tutorial, utilizziamo. `my-eks-namespace`
+ **Account del servizio Amazon EKS: nome** dell'account del servizio Amazon EKS. Per questo tutorial, utilizziamo`my-eks-serviceaccount`.
+ **image name** il nome dell'immagine dell'applicazione. Per questo tutorial, usiamo`my-keyspaces-app`.
+ **URI dell'immagine: l'URI** dell'immagine Docker di Amazon ECR.
+  **AWS ID account: l'ID** del tuo AWS account.
+ **Ruolo IAM ARN** l'ARN del ruolo IAM creato per l'account di servizio da assumere. Per questo tutorial, utilizziamo. `my-iam-role`
+ **Regione AWS del cluster Amazon EKS** in Regione AWS cui hai creato il cluster Amazon EKS.

In questa fase, distribuisci ed esegui l'applicazione che si connette ad Amazon Keyspaces e scrive i dati nella tabella.

1. Configura il file `deployment.yaml`. È necessario sostituire i seguenti valori:
   + `name`
   + `namespace`
   + `serviceAccountName`
   + `image`
   + `AWS_ROLE_ARN value`
   + Il Regione AWS pin `CASSANDRA_HOST`
   + `AWS_REGION`

   È possibile utilizzare il seguente file come esempio.

   ```
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-keyspaces-app
     namespace: my-eks-namespace
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: my-keyspaces-app
     template:
       metadata:
         labels:
           app: my-keyspaces-app
       spec:
         serviceAccountName: my-eks-serviceaccount
         containers:
         - name: my-keyspaces-app
           image: 111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository:latest
           ports:
           - containerPort: 8080
           env:
           - name: CASSANDRA_HOST
             value: "cassandra.us-east-1.amazonaws.com:9142"
           - name: CASSANDRA_DC
             value: "us-east-1"
           - name: AWS_WEB_IDENTITY_TOKEN_FILE
             value: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
           - name: AWS_ROLE_ARN
             value: "arn:aws:iam::111122223333:role/my-iam-role"
           - name: AWS_REGION
             value: "us-east-1"
   ```

1. Implementazione di `deployment.yaml`.

   ```
   kubectl apply -f deployment.yaml
   ```

   L'output dovrebbe essere simile a questo.

   ```
   deployment.apps/my-keyspaces-app created
   ```

1. Verifica lo stato del Pod nel tuo namespace del cluster Amazon EKS. 

   ```
   kubectl get pods -n my-eks-namespace
   ```

   L'output dovrebbe essere simile a quello di questo esempio.

   ```
   NAME                    READY STATUS RESTARTS AGE
   my-keyspaces-app-123abcde4f-g5hij 1/1 Running 0 75s
   ```

   Per maggiori dettagli, puoi usare il seguente comando.

   ```
   kubectl describe pod my-keyspaces-app-123abcde4f-g5hij -n my-eks-namespace
   ```

   ```
   Name:                 my-keyspaces-app-123abcde4f-g5hij
   Namespace:            my-eks-namespace
   Priority:             2000001000
   Priority Class Name:  system-node-critical
   Service Account:      my-eks-serviceaccount
   Node:                 fargate-ip-192-168-102-209.ec2.internal/192.168.102.209
   Start Time:           Thu, 23 Nov 2023 12:15:43 +0000
   Labels:               app=my-keyspaces-app
                         eks.amazonaws.com/fargate-profile=my-fargate-profile
                         pod-template-hash=6c56fccc56
   Annotations:          CapacityProvisioned: 0.25vCPU 0.5GB
                         Logging: LoggingDisabled: LOGGING_CONFIGMAP_NOT_FOUND
   Status:               Running
   IP:                   192.168.102.209
   IPs:
     IP:           192.168.102.209
   Controlled By:  ReplicaSet/my-keyspaces-app-6c56fccc56
   Containers:
     my-keyspaces-app:
       Container ID:   containerd://41ff7811d33ae4bc398755800abcdc132335d51d74f218ba81da0700a6f8c67b
       Image:          111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest
       Image ID:       111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository@sha256:fd3c6430fc5251661efce99741c72c1b4b03061474940200d0524b84a951439c
       Port:           8080/TCP
       Host Port:      0/TCP
       State:          Running
         Started:      Thu, 23 Nov 2023 12:15:19 +0000
         Finished:     Thu, 23 Nov 2023 12:16:17 +0000
       Ready:          True
       Restart Count:  1
       Environment:
         CASSANDRA_HOST:               cassandra.us-east-1.amazonaws.com:9142
         CASSANDRA_DC:                 us-east-1
         AWS_WEB_IDENTITY_TOKEN_FILE:  /var/run/secrets/eks.amazonaws.com/serviceaccount/token
         AWS_ROLE_ARN:                 arn:aws:iam::111122223333:role/my-iam-role
         AWS_REGION:                   us-east-1
         AWS_STS_REGIONAL_ENDPOINTS:   regional
       Mounts:
         /var/run/secrets/eks.amazonaws.com/serviceaccount from aws-iam-token (ro)
         /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-fssbf (ro)
   Conditions:
     Type              Status
     Initialized       True 
     Ready             True 
     ContainersReady   True 
     PodScheduled      True 
   Volumes:
     aws-iam-token:
       Type:                    Projected (a volume that contains injected data from multiple sources)
       TokenExpirationSeconds:  86400
     kube-api-access-fssbf:
       Type:                    Projected (a volume that contains injected data from multiple sources)
       TokenExpirationSeconds:  3607
       ConfigMapName:           kube-root-ca.crt
       ConfigMapOptional:       <nil>
       DownwardAPI:             true
   QoS Class:                   BestEffort
   Node-Selectors:              <none>
   Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                                node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
   Events:
     Type     Reason           Age                From               Message
     ----     ------           ----               ----               -------
     Warning  LoggingDisabled  2m13s              fargate-scheduler  Disabled logging because aws-logging configmap was not found. configmap "aws-logging" not found
     Normal   Scheduled        89s                fargate-scheduler  Successfully assigned my-eks-namespace/my-keyspaces-app-6c56fccc56-mgs2m to fargate-ip-192-168-102-209.ec2.internal
     Normal   Pulled           75s                kubelet            Successfully pulled image "111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest" in 13.027s (13.027s including waiting)
     Normal   Pulling          54s (x2 over 88s)  kubelet            Pulling image "111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest"
     Normal   Created          54s (x2 over 75s)  kubelet            Created container my-keyspaces-app
     Normal   Pulled           54s                kubelet            Successfully pulled image "111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest" in 222ms (222ms including waiting)
     Normal   Started          53s (x2 over 75s)  kubelet            Started container my-keyspaces-app
   ```

1. Controlla i log del Pod per confermare che l'applicazione è in esecuzione e può connettersi alla tabella Amazon Keyspaces. Puoi farlo con il seguente comando. Assicurati di sostituire il nome della tua distribuzione.

   ```
   kubectl logs -f my-keyspaces-app-123abcde4f-g5hij -n my-eks-namespace
   ```

   Dovresti essere in grado di visualizzare le voci di registro dell'applicazione che confermano la connessione ad Amazon Keyspaces come nell'esempio seguente.

   ```
   2:47:20.553 [s0-admin-0] DEBUG c.d.o.d.i.c.metadata.MetadataManager - [s0] Adding initial contact points [Node(endPoint=cassandra.us-east-1.amazonaws.com/1.222.333.44:9142, hostId=null, hashCode=e750d92)]
   22:47:20.562 [s0-admin-1] DEBUG c.d.o.d.i.c.c.ControlConnection - [s0] Initializing with event types [SCHEMA_CHANGE, STATUS_CHANGE, TOPOLOGY_CHANGE]
   22:47:20.564 [s0-admin-1] DEBUG c.d.o.d.i.core.context.EventBus - [s0] Registering com.datastax.oss.driver.internal.core.metadata.LoadBalancingPolicyWrapper$$Lambda$812/0x0000000801105e88@769afb95 for class com.datastax.oss.driver.internal.core.metadata.NodeStateEvent
   22:47:20.566 [s0-admin-1] DEBUG c.d.o.d.i.c.c.ControlConnection - [s0] Trying to establish a connection to Node(endPoint=cassandra.us-east-1.amazonaws.com/1.222.333.44:9142, hostId=null, hashCode=e750d92)
   ```

1. Esegui la seguente query CQL sulla tabella Amazon Keyspaces per confermare che una riga di dati sia stata scritta nella tabella:

   ```
   SELECT * from aws.user;
   ```

   Verrà visualizzato l’output seguente:

   ```
   fname    | lname | username | last_update_date 
   ----------+-------+----------+-----------------------------
   random    | k     | test     | 2023-12-07 13:58:31.57+0000
   ```

# Fase 5: Pulizia (facoltativa)
<a name="EKS-tutorial-step5"></a>

Segui questi passaggi per rimuovere tutte le risorse create in questo tutorial.

**Rimuovi le risorse create in questo tutorial**

1. Elimina la tua distribuzione. A tale scopo, è possibile utilizzare il seguente comando.

   ```
   kubectl delete deployment my-keyspaces-app -n my-eks-namespace
   ```

1. Elimina il cluster Amazon EKS e tutti i Pod in esso contenuti. Ciò elimina anche le risorse correlate come l'account di servizio e il provider di identità OIDC. A tale scopo, è possibile utilizzare il seguente comando.

   ```
   eksctl delete cluster --name my-eks-cluster --region us-east-1
   ```

1. Elimina il ruolo IAM utilizzato per l'account di servizio Amazon EKS con autorizzazioni di accesso ad Amazon Keyspaces. Innanzitutto, devi rimuovere la policy gestita associata al ruolo.

   ```
   aws iam detach-role-policy --role-name my-iam-role --policy-arn arn:aws:iam::aws:policy/AmazonKeyspacesFullAccess
   ```

   È quindi possibile eliminare il ruolo utilizzando il seguente comando.

   ```
   aws iam delete-role --role-name my-iam-role
   ```

   Per ulteriori informazioni, consulta [Eliminazione di un ruolo IAM (AWS CLI)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#roles-managingrole-deleting-cli) nella *Guida per l'utente IAM*. 

1. Elimina il repository Amazon ECR, incluse tutte le immagini in esso archiviate. Puoi farlo usando il seguente comando.

   ```
   aws ecr delete-repository \
         --repository-name my-ecr-repository \
         --force \
         --region us-east-1
   ```

   Nota che il `force` flag è necessario per eliminare un repository che contiene immagini. Per eliminare prima la tua immagine, puoi farlo usando il seguente comando. 

   ```
   aws ecr batch-delete-image \
         --repository-name my-ecr-repository \
         --image-ids imageTag=latest \
         --region us-east-1
   ```

   Per ulteriori informazioni, consulta [Eliminare un'immagine](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-delete-image) nella Amazon Elastic Container Registry User Guide.

1. Elimina lo spazio chiave e la tabella Amazon Keyspaces. L'eliminazione dello spazio chiave elimina automaticamente tutte le tabelle in quel keyspace. A tale scopo, è possibile utilizzare una delle seguenti opzioni.

------
#### [ AWS CLI ]

   ```
   aws keyspaces delete-keyspace --keyspace-name 'aws'
   ```

   Per confermare che il keyspace è stato eliminato, puoi usare il seguente comando.

   ```
   aws keyspaces list-keyspaces
   ```

   Per eliminare prima la tabella, puoi usare il seguente comando.

   ```
   aws keyspaces delete-table --keyspace-name 'aws' --table-name 'user'
   ```

   Per confermare che la tabella è stata eliminata, è possibile utilizzare il seguente comando.

   ```
   aws keyspaces list-tables --keyspace-name 'aws'
   ```

   Per ulteriori informazioni, consulta [delete keyspace](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-keyspace.html) ed [delete table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-table.html) nel *AWS CLI Command Reference.*

------
#### [ cqlsh ]

   ```
   DROP KEYSPACE IF EXISTS "aws";
   ```

   Per verificare che i tuoi keyspace siano stati eliminati, puoi usare la seguente dichiarazione.

   ```
   SELECT * FROM system_schema.keyspaces ;
   ```

   Il tuo keyspace non dovrebbe essere elencato nell'output di questa istruzione. Nota che può esserci un ritardo prima che gli spazi chiave vengano eliminati. Per ulteriori informazioni, consulta [RILASCIA LO SPAZIO CHIAVE](cql.ddl.keyspace.md#cql.ddl.keyspace.drop).

   Per eliminare prima la tabella, puoi usare il seguente comando.

   ```
   DROP TABLE "aws.user"
   ```

   Per confermare che la tabella è stata eliminata, è possibile utilizzare il seguente comando.

   ```
   SELECT * FROM system_schema.tables WHERE keyspace_name = "aws";
   ```

   La tua tabella non dovrebbe essere elencata nell'output di questa dichiarazione. Nota che può esserci un ritardo prima che la tabella venga eliminata. Per ulteriori informazioni, consulta [DROP TABLE](cql.ddl.table.md#cql.ddl.table.drop).

------