

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

# Ricerca degli endpoint di connessione in ElastiCache
<a name="Endpoints"></a>

L'applicazione si connette al ElastiCache cluster utilizzando gli endpoint. Un endpoint corrisponde all'indirizzo univoco di un nodo o di un cluster.

Puoi anche stabilire una connessione privata tra gli endpoint VPC e ElastiCache API creando un'interfaccia VPC endpoint tramite. AWS PrivateLink Per ulteriori informazioni, consulta [ElastiCache Endpoint VPC di interfaccia e API ()AWS PrivateLink](elasticache-privatelink.md).

**Quali endpoint utilizzare con Valkey o Redis OSS.**
+ Per un **nodo autonomo**, usa l'endpoint del nodo per le operazioni di lettura e scrittura.

   
+ Per i cluster **Valkey o Valkey o Redis OSS (modalità cluster disabilitata)**, utilizza l'endpoint *primario* per tutte le operazioni di scrittura. Usa l'*endpoint di lettura* per dividere equamente le connessioni in arrivo verso l'endpoint tra tutte le repliche di lettura. I vari *endpoint di nodo* (definiti in ambiente API/CLI endpoint di lettura) vengono invece impiegati per le operazioni di lettura.

   
+ Per i cluster **Valkey o Redis OSS (modalità cluster abilitata), utilizza l'*endpoint di configurazione* del cluster per tutte le operazioni che supportano i** comandi abilitati in modalità cluster. È necessario utilizzare un client che supporti Valkey Cluster o Redis OSS Cluster su Redis OSS 3.2 e versioni successive. È comunque possibile leggere dagli endpoint dei singoli nodi (in API/CLI questi casi si parla di Read Endpoints).

   

Nelle sezioni seguenti è illustrato, fase per fase, il processo di individuazione degli endpoint necessari per il motore in esecuzione.

**Quali endpoint usare con Memcached.**

Per una **cache ElastiCache serverless per Memcached**, è sufficiente acquisire il DNS e la porta dell'endpoint del cluster dalla console.

Da AWS CLI, usa il `describe-serverless-caches` comando per acquisire le informazioni sull'endpoint.

Linux

```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```

Windows

```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```

L'output dell'operazione precedente è simile al seguente (in formato JSON):

```
{
    "ServerlessCaches": [
        {
            "ServerlessCacheName": "serverless-memcached",
            "Description": "test",
            "CreateTime": 1697659642.136,
            "Status": "available",
            "Engine": "memcached",
            "MajorEngineVersion": "1.6",
            "FullEngineVersion": "21",
            "SecurityGroupIds": [
                "sg-083eda453e1e51310"
            ],
            "Endpoint": {
                "Address": "serverless-memcached-01.amazonaws.com",
                "Port":11211
            },
            "ARN": "<the ARN>",
            "SubnetIds": [
                "subnet-0cf759df15bd4dc65",
                "subnet-09e1307e8f1560d17"
            ],
            "SnapshotRetentionLimit": 0,
            "DailySnapshotTime": "03:00"
        }
    ]
}
```

Per un **cluster Memcached basato su istanze**, se si utilizza Automatic Discovery, è possibile utilizzare l'*endpoint di configurazione* del cluster per configurare il client Memcached. È necessario quindi utilizzare un client che supporti la funzione di individuazione automatica Auto Discovery.

In caso contrario, occorre configurare il client in modo che si avvalga degli endpoint di nodo individuali per le operazioni di lettura e scrittura. È necessario, inoltre, tenere traccia dei nodi eventualmente aggiunti o rimossi.

## Ricerca degli endpoint (console) del cluster Valkey o Redis OSS (modalità cluster disabilitata)
<a name="Endpoints.Find.Redis"></a>

Se un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata) ha un solo nodo, l'endpoint del nodo viene utilizzato sia per le letture che per le scritture. **Se un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata) ha più nodi, esistono tre tipi di endpoint: l'endpoint *primario*, l'endpoint reader e gli endpoint del nodo.**

L'endpoint primario è un nome DNS che viene sempre risolto nel nodo primario nel cluster. L'endpoint primario è immune a modifiche al cluster, ad esempio la promozione di una replica di lettura al ruolo primario. Per attività di scrittura, è preferibile collegare le applicazioni all'endpoint primario.

Un endpoint di lettura suddividerà in modo uniforme le connessioni in entrata all'endpoint tra tutte le repliche di lettura in un cluster per Redis OSS. ElastiCache Ulteriori fattori come, ad esempio, quando l'applicazione crea le connessioni o il modo in cui l'applicazione riutilizza le connessioni determineranno la distribuzione del traffico. Gli endpoint di lettura mantengono le modifiche ai cluster in tempo reale mano a mano che le repliche vengono aggiunte o rimosse. È possibile posizionare le repliche di lettura multiple del cluster ElastiCache for Redis OSS in diverse zone di disponibilità (AZ) per garantire l'elevata AWS disponibilità degli endpoint di lettura. 

**Nota**  
Un endpoint di lettura non è un servizio di load balancer. Si tratta di un record DNS che si risolverà in un indirizzo IP di uno dei nodi di replica in modo round robin.

Per attività di lettura, le applicazioni possono inoltre connettersi a qualsiasi nodo nel cluster. A differenza dell'endpoint primario, gli endpoint dei nodi vengono risolti in endpoint specifici. Se apporti una modifica al cluster, ad esempio aggiungendo o eliminando una replica, devi aggiornare gli endpoint dei nodi nell'applicazione.

**Per trovare gli endpoint di un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata)**

1. Accedi a Console di gestione AWS e apri la console all'indirizzo. ElastiCache [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)

1. Dal pannello di navigazione, scegli i cluster **Valkey o i cluster** **Redis OSS**.

   Apparirà la schermata dei cluster con un elenco di cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata) e Valkey o Redis OSS (modalità cluster abilitata).

1. Per trovare gli endpoint Primary and/or Reader del cluster, scegli il nome del cluster (non il pulsante alla sua sinistra).  
![\[Immagine: endpoint primario per un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata)\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/Reader-Endpoint.png)

   *Endpoint primari e Reader per un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata)*

   Se il cluster annovera un solo nodo, non c'è alcun endpoint primario e si può passare alla fase successiva.

1. **Se il cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata) dispone di nodi di replica, puoi trovare gli endpoint del nodo di replica del cluster scegliendo il nome del cluster e quindi scegliendo la scheda Nodi.**

   Così facendo, viene visualizzata una schermata con l'elenco di tutti i nodi del cluster, primario e di replica, e i relativi endpoint.  
![\[Immagine: endpoint Node per un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata)\]](http://docs.aws.amazon.com/it_it/AmazonElastiCache/latest/dg/images/ElastiCache-Endpoints-Redis-Node.png)

   *Endpoint di nodi per un cluster Valkey o Valkey o Redis OSS (modalità cluster disabilitata)*

1. Per copiare un endpoint negli appunti:

   1. Individua, uno alla volta, gli endpoint da copiare.

   1. Scegli l'icona di copia direttamente davanti all'endpoint.

   L'endpoint è stato correttamente copiato negli appunti. Per informazioni sull'utilizzo dell'endpoint per la connessione a un nodo, consulta [Connessione ai nodi Memcached](nodes-connecting.md#nodes-connecting.mem).

Un endpoint primario Valkey o Valkey o Redis OSS (modalità cluster disabilitata) ha un aspetto simile al seguente. Differisce in base all'avvenuta o mancata abilitazione della crittografia dati in transito.

**Crittografia dati in transito non abilitata**

```
clusterName.xxxxxx.nodeId.regionAndAz.cache.amazonaws.com:port
			
redis-01.7abc2d.0001.usw2.cache.amazonaws.com:6379
```

**Crittografia dati in transito abilitata**

```
master.clusterName.xxxxxx.regionAndAz.cache.amazonaws.com:port

master.ncit.ameaqx.use1.cache.amazonaws.com:6379
```

## Ricerca degli endpoint per un cluster (console) Valkey o Redis OSS (modalità cluster abilitata)
<a name="Endpoints.Find.RedisCluster"></a>

Un cluster Valkey o Redis OSS (modalità cluster abilitata) ha un unico endpoint di configurazione. Connettendosi all'endpoint di configurazione, la tua applicazione è in grado di scoprire gli endpoint primari e di lettura per ognle partizioni del cluster.

**Per trovare l'endpoint di un cluster Valkey o Redis OSS (modalità cluster abilitata)**

1. Accedi a Console di gestione AWS e apri la console all' ElastiCache indirizzo. [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)

1. Dal pannello di navigazione, scegli i cluster **Valkey o i cluster** **Redis OSS**.

   Apparirà la schermata dei cluster con un elenco di cluster. Scegli il cluster a cui desideri connetterti.

1. Per trovare l'endpoint di configurazione del cluster, scegli il nome del cluster (non il pulsante di opzione).

1. L’**endpoint di configurazione** è visualizzato sotto **i dettagli del cluster**. Per copiarlo scegli l'icona *copia* a sinistra dell'endpoint. 

## Individuazione degli endpoint di un cluster (console) (Memcached)
<a name="Endpoints.Find.Memcached"></a>

Tutti gli endpoint Memcached sono endpoint. read/write Per connettersi ai nodi in un cluster Memcached, l'applicazione può utilizzare gli endpoint di ciascun nodo o l'endpoint di configurazione del cluster, insieme all'individuazione automatica. Per avvalersi dell'individuazione automatica è necessario utilizzare un client che la supporti.

Con l'individuazione automatica, l'applicazione client si connette al cluster Memcached tramite l'endpoint di configurazione. Nel momento in cui si ridimensiona il cluster aggiungendo o rimuovendo nodi, l'applicazione viene automaticamente e immediatamente a "conoscenza" di tutti i nodi del cluster ed è in grado di connettersi a essi. Senza l'individuazione automatica, l'applicazione deve fare da sé o spetta all'utente aggiornare manualmente gli endpoint nell'applicazione, per ogni aggiunta o rimozione di un nodo. 

Per copiare un endpoint, scegli l'icona di copia direttamente davanti all'indirizzo dell'endpoint. Per informazioni sull'utilizzo dell'endpoint per la connessione a un nodo, consulta [Connessione ai nodi Memcached](nodes-connecting.md#nodes-connecting.mem).

Gli endpoint di configurazione e dei nodi sono molto simili. Le differenze sono riportate di seguito in **grassetto**.

```
myclustername.xxxxxx.cfg.usw2.cache.amazonaws.com:port   # configuration endpoint contains "cfg"
myclustername.xxxxxx.0001.usw2.cache.amazonaws.com:port  # node endpoint for node 0001
```

**Importante**  
Chi sceglie di impostare un CNAME come endpoint di configurazione Memcached, affinché il client dell'individuazione automatica lo riconosca come tale, deve includere `.cfg.` nel CNAME stesso. 

## Individuazione degli endpoint (AWS CLI)
<a name="Endpoints.Find.CLI"></a>

Per Memcached, puoi usare for AWS CLI Amazon ElastiCache per scoprire gli endpoint per nodi e cluster.

Per Redis OSS, puoi usare AWS CLI for Amazon ElastiCache per scoprire gli endpoint per nodi, cluster e anche gruppi di replica.

**Topics**
+ [Individuazione degli endpoint per nodi e cluster (AWS CLI)](#Endpoints.Find.CLI.Nodes)
+ [Individuazione degli endpoint per i gruppi di replica Valkey o Redis OSS ()AWS CLI](#Endpoints.Find.CLI.ReplGroups)

### Individuazione degli endpoint per nodi e cluster (AWS CLI)
<a name="Endpoints.Find.CLI.Nodes"></a>

Puoi usare il AWS CLI per scoprire gli endpoint di un cluster e dei suoi nodi con il comando. `describe-cache-clusters` Per i cluster Valkey o Redis OSS, il comando restituisce l'endpoint del cluster. Per i cluster Memcached, il comando restituisce l'endpoint di configurazione. Se si include il parametro facoltativo `--show-cache-node-info`, il comando restituisce, inoltre, gli endpoint dei vari nodi nel cluster.

**Example**  
Il seguente comando recupera l'endpoint di configurazione (`ConfigurationEndpoint`) e gli endpoint dei singoli nodi (`Endpoint`) del cluster Memcached *mycluster*.  
Per Linux, macOS o Unix:  

```
aws elasticache describe-cache-clusters \
    --cache-cluster-id mycluster \
    --show-cache-node-info
```
Per Windows:  

```
aws elasticache describe-cache-clusters ^
    --cache-cluster-id mycluster ^
    --show-cache-node-info
```
L'output dell'operazione sopra indicata dovrebbe essere simile a questo (in formato JSON).  

```
{
   "CacheClusters": [
   {
       "Engine": "memcached", 
       "CacheNodes": [
          {
             "CacheNodeId": "0001", 
             "Endpoint": {
                "Port": 11211, 
                "Address": "mycluster.amazonaws.com"
             }, 
                "CacheNodeStatus": "available", 
                "ParameterGroupStatus": "in-sync", 
                "CacheNodeCreateTime": "2016-09-22T21:30:29.967Z", 
                "CustomerAvailabilityZone": "us-west-2b"
          }, 
          {
             "CacheNodeId": "0002", 
             "Endpoint": {
                "Port": 11211, 
                "Address": "mycluster.amazonaws.com"
             }, 
                "CacheNodeStatus": "available", 
                "ParameterGroupStatus": "in-sync", 
                "CacheNodeCreateTime": "2016-09-22T21:30:29.967Z", 
                "CustomerAvailabilityZone": "us-west-2b"
          }, 
          {
                "CacheNodeId": "0003", 
                "Endpoint": {
                   "Port": 11211, 
                   "Address": "mycluster.amazonaws.com"
                }, 
                   "CacheNodeStatus": "available", 
                   "ParameterGroupStatus": "in-sync", 
                   "CacheNodeCreateTime": "2016-09-22T21:30:29.967Z", 
                   "CustomerAvailabilityZone": "us-west-2b"
          }
       ], 
       "CacheParameterGroup": {
       "CacheNodeIdsToReboot": [], 
       "CacheParameterGroupName": "default.memcached1.4", 
       "ParameterApplyStatus": "in-sync"
            }, 
            "CacheClusterId": "mycluster", 
            "PreferredAvailabilityZone": "us-west-2b", 
            "ConfigurationEndpoint": {
                "Port": 11211, 
                "Address": "mycluster.amazonaws.com"
            }, 
            "CacheSecurityGroups": [], 
            "CacheClusterCreateTime": "2016-09-22T21:30:29.967Z", 
            "AutoMinorVersionUpgrade": true, 
            "CacheClusterStatus": "available", 
            "NumCacheNodes": 3, 
            "ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:", 
            "CacheSubnetGroupName": "default", 
            "EngineVersion": "1.4.24", 
            "PendingModifiedValues": {}, 
            "PreferredMaintenanceWindow": "mon:09:00-mon:10:00", 
            "CacheNodeType": "cache.m4.large",
             "DataTiering": "disabled"
        }
    ]   
}
```
Chi sceglie di impostare un CNAME come endpoint di configurazione Memcached, affinché il client dell'individuazione automatica lo riconosca come tale, deve includere `.cfg.` nel CNAME stesso. Ad esempio, `mycluster.cfg.local` nel file php.ini per il parametro `session.save_path`.

**Example**  
*Per Valkey e Redis OSS, il comando seguente recupera le informazioni sul cluster per il cluster a nodo singolo mycluster.*  
Il parametro `--cache-cluster-id` può essere utilizzato con ID cluster Valkey o Redis OSS (modalità cluster disabilitata) a nodo singolo o ID di nodo specifici nei gruppi di replica. Il valore `--cache-cluster-id` di un gruppo di replica è un valore a 4 cifre come. `0001` Se `--cache-cluster-id` è l'id di un cluster (nodo) in un gruppo di replica, `replication-group-id` viene incluso nell'output.
Per Linux, macOS o Unix:  

```
aws elasticache describe-cache-clusters \
    --cache-cluster-id redis-cluster \
    --show-cache-node-info
```
Per Windows:  

```
aws elasticache describe-cache-clusters ^
    --cache-cluster-id redis-cluster ^
    --show-cache-node-info
```
L'output dell'operazione sopra indicata dovrebbe essere simile a questo (in formato JSON).  

```
{
    "CacheClusters": [
        {
            "CacheClusterStatus": "available",
            "SecurityGroups": [
                {
                    "SecurityGroupId": "sg-77186e0d",
                    "Status": "active"
                }
            ],
            "CacheNodes": [
                {
                    "CustomerAvailabilityZone": "us-east-1b",
                    "CacheNodeCreateTime": "2018-04-25T18:19:28.241Z",
                    "CacheNodeStatus": "available",
                    "CacheNodeId": "0001",
                    "Endpoint": {
                        "Address": "redis-cluster.amazonaws.com",
                        "Port": 6379
                    },
                    "ParameterGroupStatus": "in-sync"
                }
            ],
            "AtRestEncryptionEnabled": false,
            "CacheClusterId": "redis-cluster",
            "TransitEncryptionEnabled": false,
            "CacheParameterGroup": {
                "ParameterApplyStatus": "in-sync",
                "CacheNodeIdsToReboot": [],
                "CacheParameterGroupName": "default.redis3.2"
            },
            "NumCacheNodes": 1,
            "PreferredAvailabilityZone": "us-east-1b",
            "AutoMinorVersionUpgrade": true,
            "Engine": "redis",
            "AuthTokenEnabled": false,
            "PendingModifiedValues": {},
            "PreferredMaintenanceWindow": "tue:08:30-tue:09:30",
            "CacheSecurityGroups": [],
            "CacheSubnetGroupName": "default",
            "CacheNodeType": "cache.t2.small",
             "DataTiering": "disabled"
            "EngineVersion": "3.2.10",
            "ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
            "CacheClusterCreateTime": "2018-04-25T18:19:28.241Z"
        }
    ]
}
```

Per ulteriori informazioni, consulta l'argomento [describe-cache-clusters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html).

### Individuazione degli endpoint per i gruppi di replica Valkey o Redis OSS ()AWS CLI
<a name="Endpoints.Find.CLI.ReplGroups"></a>

È possibile utilizzare il AWS CLI per scoprire gli endpoint di un gruppo di replica e dei relativi cluster con il comando. `describe-replication-groups` Il comando restituisce l'endpoint primario del gruppo di replica e l'elenco di tutti i cluster (nodi) nel gruppo di replica con i loro endpoint insieme all'endpoint di lettura. 

L'operazione seguente recupera l'endpoint primario e l'endpoint di lettura per il gruppo di replica `myreplgroup`. Utilizza l'endpoint primario per tutte le operazioni di scrittura. 

```
aws elasticache describe-replication-groups \
    --replication-group-id myreplgroup
```

Per Windows:

```
aws elasticache describe-replication-groups ^
    --replication-group-id myreplgroup
```

L'aspetto dell'output di questa operazione è simile al seguente (in formato JSON).

```
{
   "ReplicationGroups": [
     {
       "Status": "available", 
       "Description": "test", 
       "NodeGroups": [
         {
            "Status": "available", 
               "NodeGroupMembers": [
                  {
                     "CurrentRole": "primary", 
                     "PreferredAvailabilityZone": "us-west-2a", 
                     "CacheNodeId": "0001", 
                     "ReadEndpoint": {
                        "Port": 6379, 
                        "Address": "myreplgroup-001.amazonaws.com"
                     }, 
                     "CacheClusterId": "myreplgroup-001"
                  }, 
                  {
                     "CurrentRole": "replica", 
                     "PreferredAvailabilityZone": "us-west-2b", 
                     "CacheNodeId": "0001", 
                     "ReadEndpoint": {
                        "Port": 6379, 
                        "Address": "myreplgroup-002.amazonaws.com"
                     }, 
                     "CacheClusterId": "myreplgroup-002"
                  }, 
                  {
                     "CurrentRole": "replica", 
                     "PreferredAvailabilityZone": "us-west-2c", 
                     "CacheNodeId": "0001", 
                     "ReadEndpoint": {
                        "Port": 6379, 
                        "Address": "myreplgroup-003.amazonaws.com"
                     }, 
                     "CacheClusterId": "myreplgroup-003"
                  }
               ], 
               "NodeGroupId": "0001", 
               "PrimaryEndpoint": {
                  "Port": 6379, 
                  "Address": "myreplgroup.amazonaws.com"
               },
               "ReaderEndpoint": {
                  "Port": 6379, 
                  "Address": "myreplgroup-ro.amazonaws.com"
               }
            }
         ], 
         "ReplicationGroupId": "myreplgroup", 
         "AutomaticFailover": "enabled", 
         "SnapshottingClusterId": "myreplgroup-002", 
         "MemberClusters": [
            "myreplgroup-001", 
            "myreplgroup-002", 
            "myreplgroup-003"
         ], 
         "PendingModifiedValues": {}
      }
   ]
}
```

Per ulteriori informazioni, consulta la sezione [describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html) nella *Documentazione di riferimento della AWS CLI *.

## Ricerca degli endpoint (API) ElastiCache
<a name="Endpoints.Find.API"></a>

Per Memcached, puoi utilizzare l' ElastiCache API Amazon per scoprire gli endpoint per nodi e cluster.

Per Redis OSS, puoi utilizzare l' ElastiCache API Amazon per scoprire gli endpoint per nodi, cluster e anche gruppi di replica.

**Topics**
+ [Ricerca di endpoint per nodi e cluster (API) ElastiCache](#Endpoints.Find.API.Nodes)
+ [Ricerca di endpoint per Valkey o Redis OSS Replication Groups (API) ElastiCache](#Endpoints.Find.API.ReplGroups)

### Ricerca di endpoint per nodi e cluster (API) ElastiCache
<a name="Endpoints.Find.API.Nodes"></a>

Puoi utilizzare l' ElastiCache API per scoprire gli endpoint di un cluster e dei relativi nodi con l'azione. `DescribeCacheClusters` Per i cluster Valkey o Redis OSS, il comando restituisce l'endpoint del cluster. Per i cluster Memcached, il comando restituisce l'endpoint di configurazione. Se si include il parametro facoltativo `ShowCacheNodeInfo`, l'operazione restituisce, inoltre, gli endpoint dei vari nodi nel cluster.

**Example**  
*Per Memcached, il comando seguente recupera l'endpoint di configurazione (`ConfigurationEndpoint`) e gli endpoint dei singoli nodi () per il cluster Memcached mycluster. `Endpoint`*  

```
https://elasticache.us-west-2.amazonaws.com/
    ?Action=DescribeCacheClusters
    &CacheClusterId=mycluster
    &ShowCacheNodeInfo=true
    &SignatureVersion=4
    &SignatureMethod=HmacSHA256
    &Timestamp=20150202T192317Z
    &Version=2015-02-02
    &X-Amz-Credential=<credential>
```
Chi sceglie di impostare un CNAME come endpoint di configurazione Memcached, affinché il client dell'individuazione automatica lo riconosca come tale, deve includere `.cfg.` nel CNAME stesso. Ad esempio, `mycluster.cfg.local` nel file php.ini per il parametro `session.save_path`.

### Ricerca di endpoint per Valkey o Redis OSS Replication Groups (API) ElastiCache
<a name="Endpoints.Find.API.ReplGroups"></a>

È possibile utilizzare l' ElastiCache API per scoprire gli endpoint di un gruppo di replica e dei relativi cluster con l'azione. `DescribeReplicationGroups` Il comando restituisce l'endpoint primario del gruppo di replica e l'elenco di tutti i cluster nel gruppo di replica con i loro endpoint insieme all'endpoint di lettura. 

La seguente operazione recupera l'endpoint primario (PrimaryEndpoint), l'endpoint del lettore () e gli endpoint dei singoli nodi (ReaderEndpoint) per il gruppo di replica. ReadEndpoint `myreplgroup` Utilizza l'endpoint primario per tutte le operazioni di scrittura.

```
https://elasticache.us-west-2.amazonaws.com/
    ?Action=DescribeReplicationGroups
    &ReplicationGroupId=myreplgroup
    &SignatureVersion=4
    &SignatureMethod=HmacSHA256
    &Timestamp=20150202T192317Z
    &Version=2015-02-02
    &X-Amz-Credential=<credential>
```

Per ulteriori informazioni, consulta [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html). 