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: Connettiti ad Amazon Keyspaces utilizzando un endpoint VPC di interfaccia
Questo tutorial illustra la configurazione e l'utilizzo di un endpoint VPC di interfaccia per Amazon Keyspaces.
*Gli endpoint VPC di interfaccia* consentono la comunicazione privata tra il tuo cloud privato virtuale (VPC) in esecuzione su Amazon VPC e Amazon Keyspaces. Gli endpoint VPC di interfaccia sono alimentati da AWS PrivateLink, un AWS servizio che consente la comunicazione privata tra e VPCs servizi. AWS Per ulteriori informazioni, consulta [Utilizzo di Amazon Keyspaces con endpoint VPC di interfaccia](vpc-endpoints.md).
**Topics**
+ [Prerequisiti e considerazioni del tutorial](vpc-endpoints-tutorial.before-you-begin.md)
+ [Fase 1: avvio di un'istanza Amazon EC2](vpc-endpoints-tutorial.launch-ec2-instance.md)
+ [Fase 2: configurazione dell'istanza Amazon EC2](vpc-endpoints-tutorial.configure-ec2-instance.md)
+ [Fase 3: creare un endpoint VPC per Amazon Keyspaces](vpc-endpoints-tutorial.create-endpoint.md)
+ [Passaggio 4: Configurare le autorizzazioni per la connessione agli endpoint VPC](vpc-endpoints-tutorial.permissions.md)
+ [Fase 5: configura il monitoraggio con CloudWatch](vpc-endpoints-tutorial.monitoring.md)
+ [Passaggio 6: (Facoltativo) Procedure consigliate per configurare la dimensione del pool di connessioni per l'applicazione](vpc-endpoints-tutorial.connections.md)
+ [Fase 7: (Facoltativo) Pulizia](vpc-endpoints-tutorial.clean-up.md)
# Prerequisiti e considerazioni del tutorial
Prima di iniziare questo tutorial, segui le istruzioni di configurazione riportate in AWS . [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. Prendi nota del nome dell'utente IAM e delle chiavi di accesso perché ti serviranno più avanti in questo tutorial.
Crea uno spazio chiave con il nome `myKeyspace` e almeno una tabella per testare la connessione utilizzando l'endpoint VPC più avanti in questo tutorial. Puoi trovare istruzioni dettagliate in. [Guida introduttiva ad Amazon Keyspaces (per Apache Cassandra)](getting-started.md)
Dopo aver completato i passaggi relativi ai prerequisiti, procedi a[Fase 1: avvio di un'istanza Amazon EC2](vpc-endpoints-tutorial.launch-ec2-instance.md).
# Fase 1: avvio di un'istanza Amazon EC2
In questa fase, viene avviata un'istanza Amazon EC2 nell'Amazon VPC predefinito. È quindi possibile creare e utilizzare un endpoint VPC per Amazon Keyspaces.
**Per avviare un'istanza Amazon EC2**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Seleziona **Avvia istanza** e completa le seguenti operazioni:
Dalla dashboard della console EC2, nella casella **Launch instance**, scegli **Launch instance**, quindi scegli **Launch instance** tra le opzioni visualizzate.
In **Nome e tag**, per **Nome, inserisci un nome** descrittivo per l'istanza.
In **Immagini dell'applicazione e del sistema operativo (Amazon Machine Image)**:
+ Scegli **Quick Start**, quindi scegli Ubuntu. Questo è il sistema operativo (OS) per l'istanza.
+ In **Amazon Machine Image (AMI)**, puoi utilizzare l'immagine predefinita contrassegnata come **idonea al piano gratuito**. Un'*Amazon Machine Image (AMI)* è una configurazione di base che serve come modello per l'istanza.
In **Tipo di istanza**:
+ Dall'elenco **Tipo di istanza**, scegliete il tipo di istanza **t2.micro**, selezionato per impostazione predefinita.
In **Coppia di chiavi (login)**, per **Nome della coppia di chiavi**, scegli una delle seguenti opzioni per questo tutorial:
+ Se non disponi di una coppia di chiavi Amazon EC2, scegli **Crea una nuova coppia di chiavi** e segui le istruzioni. Ti verrà chiesto di scaricare un file di chiave privata (*file.pem*). Questo file ti servirà in seguito quando accederai alla tua istanza Amazon EC2, quindi prendi nota del percorso del file.
+ Se disponi già di una coppia di chiavi Amazon EC2 esistente, passa a **Seleziona una coppia di chiavi** e sceglie la coppia nell'elenco. Tenere presente che si dispone già del file di chiave privata (file *.pem*) per accedere all'istanza Amazon EC2.
In **Impostazioni di rete**:
+ Scegli **Modifica**.
+ Scegli **Seleziona un gruppo di sicurezza esistente**.
+ Nell'elenco dei gruppi di sicurezza, scegli **default** (predefinito). Questo è il gruppo di sicurezza di default per il tuo ambiente VPC.
Continua con il **riepilogo**.
+ Esamina un riepilogo della configurazione dell'istanza nel pannello **Riepilogo**. Al termine, scegli **Avvia istanza**.
1. Nella schermata di completamento della nuova istanza Amazon EC2, scegli il riquadro **Connect to instance**. La schermata successiva mostra le informazioni necessarie e i passaggi necessari per connettersi alla nuova istanza. Prendi nota delle seguenti informazioni:
+ Il comando di esempio per proteggere il file chiave
+ La stringa di connessione
+ Il **nome IPv4 DNS pubblico**
Dopo aver preso nota delle informazioni in questa pagina, puoi continuare con il passaggio successivo di questo tutorial ([Fase 2: configurazione dell'istanza Amazon EC2](vpc-endpoints-tutorial.configure-ec2-instance.md)).
**Nota**
L'istanza Amazon EC2 diventerà disponibile nell'arco di alcuni minuti. Prima di continuare, verificare che **Stato istanza** sia `running` e che tutti i controlli di **verifica stato** siano stati superati.
# Fase 2: configurazione dell'istanza Amazon EC2
Quando l'istanza Amazon EC2 è disponibile, puoi accedervi e prepararla per il primo utilizzo.
**Nota**
I passaggi seguenti presuppongono che ti stia connettendo alla tua istanza Amazon EC2 da un computer che esegue Linux. Per altri modi di connessione, consulta [Connect to your Linux istance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) nella *Amazon EC2 User* Guide.
**Per configurare la tua istanza Amazon EC2**
1. Devi autorizzare il traffico SSH in entrata verso la tua istanza Amazon EC2. Per fare ciò, crea un nuovo gruppo di sicurezza EC2, quindi assegna il gruppo di sicurezza alla tua istanza EC2.
1. Fare clic su **Security Groups (Gruppi di sicurezza)** nel pannello di navigazione.
1. Scegli **Crea gruppo di sicurezza**. Nella finestra **Crea gruppo di sicurezza** effettua le operazioni seguenti:
+ **Nome del gruppo di sicurezza**: inserisci un nome per il tuo gruppo di sicurezza. Ad esempio: `my-ssh-access`
+ **Descrizione**: inserisci una breve descrizione per il gruppo di sicurezza.
+ **VPC**: scegli il tuo VPC predefinito.
+ Nella sezione **Regole in entrata**, scegli **Aggiungi regola** e procedi come segue:
+ **Tipo**: scegli **SSH**.
+ **Fonte**: scegli il **mio IP**.
+ Scegli **Aggiungi regola**.
Nella parte inferiore della pagina, conferma le impostazioni di configurazione e scegli **Crea gruppo di sicurezza**.
1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**.
1. Scegli l'istanza Amazon EC2 avviata in [Fase 1: avvio di un'istanza Amazon EC2](vpc-endpoints-tutorial.launch-ec2-instance.md).
1. Scegli **Azioni**, scegli **Sicurezza**, quindi scegli **Modifica gruppi di sicurezza**.
1. In **Modifica gruppi di sicurezza**, vai a **Gruppi di sicurezza associati** e inserisci il gruppo di sicurezza che hai creato in precedenza in questa procedura (ad esempio,`my-ssh-access`). Dovrebbe essere selezionato anche il gruppo di sicurezza `default` esistente. Conferma le impostazioni di configurazione e scegli **Salva**.
1. Usa il seguente comando per proteggere il tuo file di chiave privata dall'accesso. Se salti questo passaggio, la connessione fallisce.
```
chmod 400 path_to_file/my-keypair.pem
```
1. Utilizza il comando `ssh` per accedere all'istanza Amazon EC2, come nell'esempio seguente.
```
ssh -i path_to_file/my-keypair.pem ubuntu@public-dns-name
```
È necessario specificare il file di chiave privata (*file.pem*) e il nome DNS pubblico dell'istanza. Consulta [Fase 1: avvio di un'istanza Amazon EC2](vpc-endpoints-tutorial.launch-ec2-instance.md).
L'ID accesso è `ubuntu`. Non è richiesta una password.
*Per ulteriori informazioni su come consentire le connessioni alla tua istanza Amazon EC2 e per AWS CLI istruzioni, consulta [Autorizza il traffico in entrata per le tue istanze Linux nella Guida per l'](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html)utente di Amazon EC2.*
1. Scarica e installa la versione più recente di. AWS Command Line Interface
1. Installare `unzip`.
```
sudo apt install unzip
```
1. Scarica il `zip` file con AWS CLI.
```
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
```
1. Decomprimere il file.
```
unzip awscliv2.zip
```
1. Installa il AWS CLI.
```
sudo ./aws/install
```
1. Conferma la versione dell' AWS CLI installazione.
```
aws --version
```
L'output dovrebbe essere simile al seguente:
```
aws-cli/2.9.19 Python/3.9.11 Linux/5.15.0-1028-aws exe/x86_64.ubuntu.22 prompt/off
```
1. Configura AWS le tue credenziali, come illustrato nell'esempio seguente. Quando richiesto, inserisci AWS l'ID della chiave di accesso, la chiave segreta e il nome predefinito della regione.
```
aws configure
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-east-1
Default output format [None]:
```
1. Aggiungi regole al tuo gruppo VPCs di sicurezza che consentano l'accesso HTTP, HTTPS e SSH in entrata dagli indirizzi. IPv6
1. Per confermare che il tuo endpoint VPC è stato configurato correttamente, devi utilizzare una connessione `cqlsh` ad Amazon Keyspaces. Se utilizzi il tuo ambiente locale o l'editor CQL di Amazon Keyspaces in Console di gestione AWS, la connessione passa automaticamente attraverso l'endpoint pubblico anziché l'endpoint VPC. Da utilizzare `cqlsh` per testare la connessione dell'endpoint VPC in questo tutorial, completa le istruzioni di configurazione in. [Utilizzo `cqlsh` per connettersi ad Amazon Keyspaces](programmatic.cqlsh.md)
Ora sei pronto per creare un endpoint VPC dual-stack per Amazon Keyspaces.
# Fase 3: creare un endpoint VPC per Amazon Keyspaces
In questa fase, crei un endpoint VPC dual-stack per Amazon Keyspaces utilizzando. AWS CLI*Per creare l'endpoint VPC utilizzando la console VPC, puoi seguire le istruzioni per la creazione di [un endpoint VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint) nella Guida.AWS PrivateLink * **Quando filtrate per il nome del servizio, immettete.** **Cassandra**
**Per creare un endpoint VPC utilizzando AWS CLI**
1. Prima di iniziare, verifica di poter comunicare con Amazon Keyspaces utilizzando il suo endpoint pubblico.
```
aws keyspaces list-tables --keyspace-name 'myKeyspace'
```
L'output mostra un elenco di tabelle Amazon Keyspaces contenute nel keyspace specificato. Se non hai tabelle, l'elenco è vuoto.
```
{
"tables": [
{
"keyspaceName": "myKeyspace",
"tableName": "myTable1",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/myTable1"
},
{
"keyspaceName": "myKeyspace",
"tableName": "myTable2",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/myTable2"
}
]
}
```
1. Verifica che Amazon Keyspaces sia un servizio disponibile per la creazione di endpoint VPC nella regione corrente. AWS Il comando è mostrato in grassetto, seguito dall'output di esempio.
```
aws ec2 describe-vpc-endpoint-services
{
"ServiceNames": [
"com.amazonaws.us-east-1.cassandra",
"com.amazonaws.us-east-1.cassandra-fips"
"api.aws.us-east-1.cassandra-streams"
]
}
```
Se Amazon Keyspaces è uno dei servizi disponibili nell'output del comando, puoi procedere con la creazione di un endpoint VPC.
1. Per connetterti ad Amazon Keyspaces utilizzando endpoint dual-stack IPv6 abilitati, verifica che il tuo VPC supporti e configura le sottoreti con il supporto. IPv6 IPv6 Per aggiungere IPv6 supporto a un VPC esistente che attualmente supporta solo VPC IPv4, consulta il [ IPv6 supporto per il tuo VPC nella Amazon *VPC*](https://docs.aws.amazon.com/vpc/latest/userguide/) User Guide;.
1. Determinare l'identificatore VPC.
```
aws ec2 describe-vpcs
{
"Vpcs": [
{
"OwnerId": "111122223333",
"InstanceTenancy": "default",
"Ipv6CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-0000aaa0a00a00aa0",
"Ipv6CidrBlock": "2600:1f18:e19:7d00::/56",
"Ipv6CidrBlockState": {
"State": "associated"
},
"NetworkBorderGroup": "us-east-1",
"Ipv6Pool": "Amazon",
"Ipv6AddressAttribute": "public",
"IpSource": "amazon"
}
],
"CidrBlockAssociationSet": [
{
"AssociationId": "vpc-cidr-assoc-00a0000a",
"CidrBlock": "111.11.0.0/16",
"CidrBlockState": {
"State": "associated"
}
}
],
"IsDefault": true,
"BlockPublicAccessStates": {
"InternetGatewayBlockMode": "off"
},
"VpcId": "vpc-a1234bcd",
"State": "available",
"CidrBlock": "111.11.0.0/16",
"DhcpOptionsId": "dopt-a00aaaaa"
}
]
}
```
Nell'output di esempio, l'ID VPC è `vpc-a1234bcd`.
1. Utilizza un filtro per raccogliere dettagli sulle sottoreti del VPC.
```
aws ec2 describe-subnets --filters "Name=vpc-id,Values=vpc-a1234bcd"
{
"Subnets": [
{
"AvailabilityZoneId": "use1-az1",
"MapCustomerOwnedIpOnLaunch": false,
"OwnerId": "111122223333",
"AssignIpv6AddressOnCreation": false,
"Ipv6CidrBlockAssociationSet": [
{
"AssociationId": "subnet-cidr-assoc-05d75732736740283",
"Ipv6CidrBlock": "***********************",
"Ipv6CidrBlockState": {
"State": "associated"
},
"Ipv6AddressAttribute": "public",
"IpSource": "amazon"
}
],
"SubnetArn": "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-70b24b16",
"EnableDns64": false,
"Ipv6Native": false,
"PrivateDnsNameOptionsOnLaunch": {
"HostnameType": "ip-name",
"EnableResourceNameDnsARecord": false,
"EnableResourceNameDnsAAAARecord": false
},
"BlockPublicAccessStates": {
"InternetGatewayBlockMode": "off"
},
"SubnetId": "subnet-70b24b16",
"State": "available",
"VpcId": "vpc-a1234bcd",
"CidrBlock": "**********/20",
"AvailableIpAddressCount": 4089,
"AvailabilityZone": "us-east-1a",
"DefaultForAz": true,
"MapPublicIpOnLaunch": true
},
{
"AvailabilityZoneId": "use1-az2",
"MapCustomerOwnedIpOnLaunch": false,
"OwnerId": "111122223333",
"AssignIpv6AddressOnCreation": false,
"Ipv6CidrBlockAssociationSet": [
{
"AssociationId": "subnet-cidr-assoc-0ec6fb253e05b17eb",
"Ipv6CidrBlock": "***********************",
"Ipv6CidrBlockState": {
"State": "associated"
},
"Ipv6AddressAttribute": "public",
"IpSource": "amazon"
}
],
"SubnetArn": "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-c63ffbe7",
"EnableDns64": false,
"Ipv6Native": false,
"PrivateDnsNameOptionsOnLaunch": {
"HostnameType": "ip-name",
"EnableResourceNameDnsARecord": false,
"EnableResourceNameDnsAAAARecord": false
},
"BlockPublicAccessStates": {
"InternetGatewayBlockMode": "off"
},
"SubnetId": "subnet-c63ffbe7",
"State": "available",
"VpcId": "vpc-a1234bcd",
"CidrBlock": "***********/20",
"AvailableIpAddressCount": 4087,
"AvailabilityZone": "us-east-1b",
"DefaultForAz": true,
"MapPublicIpOnLaunch": true
}
]
}
```
Nell'output di esempio, sono disponibili due IDs sottoreti: e. `subnet-70b24b16` `subnet-c63ffbe7`
1. Crea l'endpoint VPC. Per il parametro `--vpc-id`, specificare l'ID VPC della fase precedente. Per il `--subnet-ids` parametro, specificate la sottorete IDs del passaggio precedente. Utilizzate il `--vpc-endpoint-type` parametro per definire l'endpoint come interfaccia. Per creare un endpoint dual-stack, usa. `--ip-address-type dualstack` *Per ulteriori informazioni sul comando, vedere nel Command Reference [https://docs.aws.amazon.com/cli/latest/reference/ec2/create-vpc-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-vpc-endpoint.html).AWS CLI *
```
aws ec2 create-vpc-endpoint \
--vpc-endpoint-type Interface \
--vpc-id vpc-a1234bcd \
--ip-address-type dualstack \
--service-name com.amazonaws.us-east-1.cassandra \
--subnet-ids subnet-70b24b16 subnet-c63ffbe7
{
"VpcEndpoint": {
"VpcEndpointId": "vpce-000000abc111d2ef3",
"VpcEndpointType": "Interface",
"VpcId": "vpc-a1234bcd",
"ServiceName": "com.amazonaws.us-east-1.cassandra",
"State": "pending",
"RouteTableIds": [],
"SubnetIds": [
"subnet-70b24b16",
"subnet-c63ffbe7"
],
"Groups": [
{
"GroupId": "sg-0123456789",
"GroupName": "default"
}
],
"IpAddressType": "dualstack",
"DnsOptions": {
"DnsRecordIpType": "dualstack"
},
"PrivateDnsEnabled": true,
"RequesterManaged": false,
"NetworkInterfaceIds": [
"eni-08cd525f72ea6f1fa",
"eni-07b1f6c895169d8fb"
],
"DnsEntries": [
{
"DnsName": "vpce-0000000000-1234567.cassandra.us-east-1.vpce.amazonaws.com",
"HostedZoneId": "Z7HUB22UULQXV"
},
{
"DnsName": "vpce-0000000000-1234567-us-east-1a.cassandra.us-east-1.vpce.amazonaws.com",
"HostedZoneId": "Z7HUB22UULQXV"
},
{
"DnsName": "cassandra.us-east-1.amazonaws.com",
"HostedZoneId": "ZONEIDPENDING"
},
{
"DnsName": "cassandra.us-east-1.api.aws",
"HostedZoneId": "ZONEIDPENDING"
}
],
"CreationTimestamp": "2025-09-19T15:19:19.266000+00:00",
"OwnerId": "111122223333",
"ServiceRegion": "us-east-1"
}
}
```
# Passaggio 4: Configurare le autorizzazioni per la connessione agli endpoint VPC
Le procedure in questa fase dimostrano come configurare regole e autorizzazioni per l'utilizzo dell'endpoint VPC con Amazon Keyspaces.
**Per configurare una regola in entrata per il nuovo endpoint per consentire il traffico TCP in entrata**
1. Nella console Amazon VPC, nel pannello a sinistra, scegli **Endpoints e scegli l'endpoint** creato nel passaggio precedente.
1. Scegli **Gestisci gruppi di sicurezza**, quindi scegli il gruppo di sicurezza associato a questo endpoint.
1. Scegli **Regole in entrata, quindi scegli Modifica regole** **in entrata**.
1. Aggiungi una regola in entrata con **Digita** come **CQLSH/CASSANDRA**. **Questo imposta automaticamente l'**intervallo di porte** su 9142.**
1. Per salvare la nuova regola in entrata, scegli **Salva** regole.
**Per configurare le autorizzazioni utente IAM**
1. Verifica che l'utente IAM utilizzato per connettersi ad Amazon Keyspaces disponga delle autorizzazioni appropriate. In AWS Identity and Access Management (IAM), puoi utilizzare la policy AWS gestita `AmazonKeyspacesReadOnlyAccess` per concedere all'utente IAM l'accesso in lettura ad Amazon Keyspaces.
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel pannello di controllo della console IAM, seleziona **Utenti**, quindi scegli l'utente IAM dall'elenco.
1. Nella pagina **Summary (Riepilogo)**, scegli **Add permissions (Aggiungi autorizzazioni)**.
1. Scegli **Attach existing policies directly (Collega direttamente le policy esistenti)**.
1. Dall'elenco delle politiche, scegli **AmazonKeyspacesReadOnlyAccess**, quindi scegli **Avanti: revisione**.
1. Scegli **Add Permissions (Aggiungi autorizzazioni)**.
1. Verifica di poter accedere ad Amazon Keyspaces tramite l'endpoint VPC.
```
aws keyspaces list-tables --keyspace-name 'my_Keyspace'
```
Se lo desideri, puoi provare altri AWS CLI comandi per Amazon Keyspaces. Per ulteriori informazioni, consulta la sezione relativa alle [informazioni di riferimento ai comandi di AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/).
**Nota**
Le autorizzazioni minime richieste a un utente o ruolo IAM per accedere ad Amazon Keyspaces sono le autorizzazioni di lettura per la tabella di sistema, come illustrato nella seguente policy. Per ulteriori informazioni sulle autorizzazioni basate su policy, consulta. [Esempi di policy basate sull'identità di Amazon Keyspaces](security_iam_id-based-policy-examples.md)
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"cassandra:Select"
],
"Resource":[
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*"
]
}
]
}
```
1. Concedi all'utente IAM l'accesso in lettura all'istanza Amazon EC2 con il VPC.
Quando utilizzi Amazon Keyspaces con endpoint VPC, devi concedere all'utente o al ruolo IAM che accede ad Amazon Keyspaces le autorizzazioni di sola lettura per l'istanza *Amazon EC2 e il VPC per raccogliere i dati degli endpoint e delle interfacce* di rete. Amazon Keyspaces memorizza queste informazioni nella `system.peers` tabella e le utilizza per gestire le connessioni.
**Nota**
Le policy gestite `AmazonKeyspacesFullAccess` includono `AmazonKeyspacesReadOnlyAccess_v2` le autorizzazioni necessarie per consentire ad Amazon Keyspaces di accedere all'istanza Amazon EC2 per leggere informazioni sugli endpoint VPC di interfaccia disponibili.
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Nella dashboard della console IAM, scegli **Policies**.
1. Scegli **Crea policy**, quindi scegli la scheda **JSON**.
1. Copia la seguente politica e scegli **Avanti: Tag**.
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"ListVPCEndpoints",
"Effect":"Allow",
"Action":[
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeVpcEndpoints"
],
"Resource": "*"
}
]
}
```
1. Scegli **Avanti: revisione**, inserisci `keyspacesVPCendpoint` il nome della politica e scegli **Crea politica**.
1. Nel pannello di controllo della console IAM, seleziona **Utenti**, quindi scegli l'utente IAM dall'elenco.
1. Nella pagina **Summary (Riepilogo)**, scegli **Add permissions (Aggiungi autorizzazioni)**.
1. Scegli **Attach existing policies directly (Collega direttamente le policy esistenti)**.
1. Dall'elenco delle politiche, scegli **gli spazi chiave VPCendpoint**, quindi scegli **Avanti: revisione**.
1. Scegli **Add Permissions (Aggiungi autorizzazioni)**.
1. Per verificare che la `system.peers` tabella Amazon Keyspaces venga aggiornata con le informazioni sul VPC, esegui la seguente query dalla tua istanza Amazon EC2 utilizzando. `cqlsh` Se non l'hai ancora installata `cqlsh` sulla tua istanza Amazon EC2 nella fase 2, segui le istruzioni riportate in. [Utilizzo di `cqlsh-expansion` per connettersi ad Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh)
```
SELECT * FROM system.peers;
```
L'output restituisce nodi con indirizzi IPv6 IP privati, a seconda della configurazione del VPC e della sottorete nella regione. AWS
```
peer | data_center | host_id | preferred_ip | rack | release_version | rpc_address | schema_version | tokens
-----------------------------------------+-------------+--------------------------------------+-----------------------------------------+-----------+-----------------+-----------------------------------------+--------------------------------------+---------------------------------------------
2600:1111:2222:3333:283b:8e6:d04f | us-east-1 | dddddddd-7a22-3582-a73d-49338a686a53 | 2600:1111:2222:3333:283b:8e6:d04f | us-east-1 | 3.11.2 | 2600:1111:2222:3333:283b:8e6:d04f | 05deae2d-6405-494d-a965-c0e5836bcb3c | {'85070591730234615865843651857942052863'}
2600:1111:2222:4444:7d26:5a09:1b44 | us-east-1 | 66666666-035d-37ef-a247-19a6a867ab09 | 2600:1111:2222:4444:7d26:5a09:1b44 | us-east-1 | 3.11.2 | 2600:1111:2222:4444:7d26:5a09:1b44 | 05deae2d-6405-494d-a965-c0e5836bcb3c | {'170141183460469231731687303715884105726'}
```
**Nota**
È necessario utilizzare una `cqlsh` connessione ad Amazon Keyspaces per confermare che l'endpoint VPC sia stato configurato correttamente. Se utilizzi il tuo ambiente locale o l'editor CQL di Amazon Keyspaces in Console di gestione AWS, la connessione passa automaticamente attraverso l'endpoint pubblico anziché l'endpoint VPC. Se vedi nove indirizzi IP, queste sono le voci che Amazon Keyspaces scrive automaticamente nella `system.peers` tabella per le connessioni endpoint pubbliche.
# Fase 5: configura il monitoraggio con CloudWatch
Questo passaggio mostra come utilizzare Amazon per CloudWatch monitorare la connessione degli endpoint VPC ad Amazon Keyspaces.
AWS PrivateLink pubblica punti dati CloudWatch sugli endpoint dell'interfaccia. Puoi utilizzare le metriche per verificare che le prestazioni del sistema siano quelle previste. Lo spazio dei `AWS/PrivateLinkEndpoints` nomi in CloudWatch include le metriche per gli endpoint dell'interfaccia. *Per ulteriori informazioni, consulta le [CloudWatch metriche](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-cloudwatch-metrics.html) contenute nella Guida. AWS PrivateLinkAWS PrivateLink *
**Per creare una CloudWatch dashboard con le metriche degli endpoint VPC**
1. Apri la console all' CloudWatch indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel pannello di navigazione seleziona **Dashboards** (Pannelli di controllo). Quindi scegli **Crea dashboard**. Inserisci un nome per la dashboard e scegli **Crea**.
1. In **Aggiungi widget**, scegli **Numero**.
1. In **Metriche**, scegli **PrivateLinkEndpointsAWS/**.
1. Scegli il **tipo di endpoint, il nome del servizio, l'ID endpoint VPC, l'ID** VPC.
1. **Seleziona le metriche `ActiveConnections` e `NewConnections` scegli Crea widget.**
1. Salva la dashboard.
La `ActiveConnections` metrica è definita come il numero di connessioni attive simultanee che l'endpoint ha ricevuto nell'ultimo periodo di un minuto. La `NewConnections` metrica è definita come il numero di nuove connessioni stabilite tramite l'endpoint nell'ultimo periodo di un minuto.
*Per ulteriori informazioni sulla creazione di dashboard, consulta [Create dashboard](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/create_dashboard.html) nella Guida per l'utente. CloudWatch *
# Passaggio 6: (Facoltativo) Procedure consigliate per configurare la dimensione del pool di connessioni per l'applicazione
In questa sezione, descriviamo come determinare la dimensione ideale del pool di connessioni in base ai requisiti di velocità di trasmissione delle query dell'applicazione.
Amazon Keyspaces consente un massimo di 3.000 query CQL al secondo per connessione TCP. Quindi non c'è praticamente alcun limite al numero di connessioni che un driver può stabilire con Amazon Keyspaces. Tuttavia, ti consigliamo di adattare la dimensione del pool di connessioni ai requisiti della tua applicazione e di considerare gli endpoint disponibili quando utilizzi Amazon Keyspaces con connessioni endpoint VPC.
La dimensione del pool di connessioni viene configurata nel driver client. Ad esempio, in base a un pool locale di **2** dimensioni e a un endpoint di interfaccia VPC creato in **3** zone di disponibilità, il driver stabilisce **6** connessioni per l'interrogazione (7 in totale, inclusa una connessione di controllo). Utilizzando queste 6 connessioni, è possibile supportare un massimo di 18.000 query CQL al secondo.
Se l'applicazione deve supportare 40.000 query CQL al secondo, procedi a ritroso partendo dal numero di query necessarie per determinare la dimensione del pool di connessioni richiesta. Per supportare 40.000 query CQL al secondo, è necessario configurare la dimensione del pool locale in modo che sia almeno 5, il che supporta un minimo di 45.000 query CQL al secondo.
È possibile monitorare se si supera la quota per il numero massimo di operazioni al secondo, per connessione utilizzando la metrica nel namespace. `PerConnectionRequestRateExceeded` CloudWatch `AWS/Cassandra` La `PerConnectionRequestRateExceeded` metrica mostra il numero di richieste ad Amazon Keyspaces che superano la quota per la frequenza di richieste per connessione.
Gli esempi di codice in questo passaggio mostrano come stimare e configurare il pool di connessioni quando si utilizzano gli endpoint VPC di interfaccia.
------
#### [ Java ]
È possibile configurare il numero di connessioni per pool nel driver Java. Per un esempio completo di connessione al driver di un client Java, vedere[Utilizzo di un driver client Java Cassandra per accedere ad Amazon Keyspaces a livello di programmazione](using_java_driver.md).
All'avvio del driver client, viene stabilita innanzitutto la connessione di controllo per le attività amministrative, ad esempio le modifiche allo schema e alla topologia. Quindi vengono create le connessioni aggiuntive.
Nell'esempio seguente, la configurazione del driver delle dimensioni del pool locale è specificata come 2. Se l'endpoint VPC viene creato su 3 sottoreti all'interno del VPC, il risultato è `NewConnections` 7 ingressi per l'endpoint dell'interfaccia, come mostrato CloudWatch nella formula seguente.
```
NewConnections = 3 (VPC subnet endpoints created across) * 2 (pool size) + 1 ( control connection)
```
```
datastax-java-driver {
basic.contact-points = [ "cassandra.us-east-1.amazonaws.com:9142"]
advanced.auth-provider{
class = PlainTextAuthProvider
username = "ServiceUserName"
password = "ServicePassword"
}
basic.load-balancing-policy {
local-datacenter = "us-east-1"
slow-replica-avoidance = false
}
advanced.ssl-engine-factory {
class = DefaultSslEngineFactory
truststore-path = "./src/main/resources/cassandra_truststore.jks"
truststore-password = "my_password"
hostname-validation = false
}
advanced.connection {
pool.local.size = 2
}
}
```
Se il numero di connessioni attive non corrisponde alla dimensione del pool configurato (aggregazione tra sottoreti) \$1 1 connessione di controllo, qualcosa impedisce la creazione delle connessioni.
------
#### [ Node.js ]
È possibile configurare il numero di connessioni per pool nel driver Node.js. Per un esempio completo di connessione al driver client Node.js, vedere[Utilizzo di un driver client Cassandra Node.js per accedere ad Amazon Keyspaces a livello di codice](using_nodejs_driver.md).
L'esempio di codice riportato di seguito utilizza il *keyspaces-bundle.pem* file per il certificato digitale. Per ulteriori informazioni, consulta [Prima di iniziare](using_nodejs_driver.md#using_nodejs_driver.BeforeYouBegin).
Per il seguente esempio di codice, la configurazione del driver della dimensione del pool locale è specificata come 1. Se l'endpoint VPC viene creato su 4 sottoreti all'interno del VPC, si ottengono `NewConnections` 5 ingressi per l'endpoint dell'interfaccia, come mostrato CloudWatch nella formula seguente.
```
NewConnections = 4 (VPC subnet endpoints created across) * 1 (pool size) + 1 ( control connection)
```
```
const cassandra = require('cassandra-driver');
const fs = require('fs');
const types = cassandra.types;
const auth = new cassandra.auth.PlainTextAuthProvider('ServiceUserName', 'ServicePassword');
const sslOptions1 = {
ca: [
fs.readFileSync('/home/ec2-user/keyspaces-bundle.pem', 'utf-8')],
host: 'cassandra.us-east-1.amazonaws.com',
rejectUnauthorized: true
};
const client = new cassandra.Client({
contactPoints: ['cassandra.us-east-1.amazonaws.com'],
localDataCenter: 'us-east-1',
pooling: { coreConnectionsPerHost: { [types.distance.local]: 1 } },
consistency: types.consistencies.localQuorum,
queryOptions: { isIdempotent: true },
authProvider: auth,
sslOptions: sslOptions1,
protocolOptions: { port: 9142 }
});
```
------
# Fase 7: (Facoltativo) Pulizia
Se desideri eliminare le risorse che hai creato in questo tutorial, segui queste procedure.
**Per rimuovere l'endpoint VPC per Amazon Keyspaces**
1. Accedi all'istanza Amazon EC2.
1. Determina l'ID dell'endpoint VPC utilizzato per Amazon Keyspaces. Se si omettono i `grep` parametri, vengono visualizzate le informazioni sugli endpoint VPC per tutti i servizi.
```
aws ec2 describe-vpc-endpoint-services | grep ServiceName | grep cassandra
{
"VpcEndpoint": {
"PolicyDocument": "{\"Version\":\"2000-00-00",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":\"*\",\"Action\":\"*\",\"Resource\":\"*\"}]}",
"VpcId": "vpc-a1234bcd",
"State": "available",
"ServiceName": "com.amazonaws.us-east-1.cassandra",
"RouteTableIds": [],
"VpcEndpointId": "vpce-1a23b4c5",
"CreationTimestamp": "2025-07-26T22:00:14Z"
}
}
```
Nell'output di esempio, l'ID endpoint VPC è *vpce-1a23b4c5*. Assicurati di sostituire questo valore con il tuo.
1. Eliminare l'endpoint VPC.
```
aws ec2 delete-vpc-endpoints --vpc-endpoint-ids vpce-1a23b4c5
{
"Unsuccessful": []
}
```
L'array vuoto `[]` indica la riuscita dell'operazione (non ci sono state richieste non riuscite).
**Come terminare l'istanza Amazon EC2**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**.
1. Scegli l'istanza Amazon EC2.
1. Scegli **Azioni**, scegli **Stato dell'istanza**, quindi scegli **Termina.**
1. Nella finestra di conferma scegli **Sì, termina**.