

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Encontrar endpoints de conexão no ElastiCache
<a name="Endpoints"></a>

Sua aplicação conecta-se ao seu cluster do ElastiCache usando endpoints. Um endpoint é o endereço exclusivo de um nó ou cluster.

Também é possível estabelecer uma conexão privada entre a VPC e os endpoints da API do ElastiCache criando um endpoint da VPC da interface por meio do AWS PrivateLink. Para obter mais informações, consulte [ElastiCache API e interface VPC endpoints ()AWS PrivateLink](elasticache-privatelink.md).

**Quais endpoints usar com o Valkey ou Redis OSS.**
+ Para o **nó autônomo**, use o endpoint do nó para operações de leitura e gravação.

   
+ Para **clusters do Valkey ou Redis OSS (modo cluster desabilitado)**, use o *Endpoint primário* para todas as operações de gravação. Use o *Endpoint de leitor* para dividir uniformemente as conexões de entrada no endpoint entre todas as réplicas de leitura. Use os *Endpoints de nó* individuais para operações de leitura (na API/CLI, eles são chamados de Endpoints de leitura).

   
+ Para **clusters do Valkey ou do Redis OSS (modo cluster habilitado)**, use o *Endpoint de configuração* do cluster para todas as operações com suporte a comandos do modo cluster habilitado. Você deve usar um cliente que ofereça suporte ao cluster do Valkey ou ao cluster do Redis OSS no Redis OSS 3.2 e superior. Você ainda pode ler de endpoints de nó individuais (na API/CLI, eles se chamam Endpoints de leitura).

   

As seções a seguir orientam pelo processo de localização dos endpoints necessários para o mecanismo que você está executando.

**Quais endpoints usar com o Memcached.**

Para o **cache com tecnologia sem servidor do ElastiCache para o Memcached**, basta adquirir o DNS do endpoint do cluster e a porta do console.

Na AWS CLI, use o comando `describe-serverless-caches` para adquirir as informações do endpoint.

Linux

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

Windows

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

O resultado da operação acima deve ser semelhante a este (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"
        }
    ]
}
```

**Para um cluster do Memcached com base na instância**, se usar a descoberta automática, você poderá usar o *endpoint de configuração* do cluster para configurar o cliente do Memcached. Isso significa que você deve usar um cliente que ofereça suporte para Descoberta automática.

Se você não usar a Descoberta automática, deverá configurar seu cliente para usar os endpoints de nó individuais para leituras e gravações. Você também deve acompanhá-los à medida que adiciona e remove nós.

## Localização de endpoints de um cluster do Valkey ou do Redis OSS (modo cluster desabilitado) (console)
<a name="Endpoints.Find.Redis"></a>

Se um cluster do Valkey ou Redis OSS (modo cluster desabilitado) tiver apenas um nó, o endpoint desse nó será usado para tanto para leituras quanto para gravações. Se um cluster do Valkey ou Redis OSS (modo cluster desabilitado) tiver vários nós, há três tipos de endpoints: o *endpoint primário*, o *endpoint leitor* e os *endpoints de nó*.

O endpoint primário é um nome DNS que sempre é resolvido para o nó primário no cluster. O endpoint primário é imune às alterações no seu cluster, como promover uma réplica de leitura para a função primária. Para atividades de gravação, recomendamos que suas aplicações se conectem ao endpoint primário.

Um endpoint de leitor divide uniformemente as conexões de entrada no endpoint entre todas as réplicas de leitura em um cluster do ElastiCache para Redis OSS. Fatores adicionais, como quando o aplicativo cria as conexões ou como o aplicativo (re)usa as conexões determinarão a distribuição do tráfego. Os endpoints de leitor acompanham as alterações do cluster em tempo real à medida que réplicas são adicionadas ou removidas. Você pode colocar várias réplicas de leitura do seu cluster do ElastiCache para Redis OSS em diferentes zonas de disponibilidade da AWS (AZ) para garantir a alta disponibilidade dos endpoints leitores. 

**nota**  
Um endpoint leitor não é um balanceador de carga. É um registro DNS que vai resolver para um endereço IP de um dos nós de réplica em uma forma round robin.

Para atividades de leitura, os aplicativos também podem se conectar a qualquer nó no cluster. Ao contrário do endpoint primário, endpoints de nó são resolvidos para endpoints específicos. Se você fizer uma alteração no cluster, como adicionar ou excluir uma réplica, deverá atualizar os endpoints de nó no seu aplicativo.

**Para descobrir endpoints de um cluster do Valkey ou Redis OSS (modo cluster desabilitado) (console)**

1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).

1. No painel de navegação, escolha **Clusters do Valkey** ou **Clusters do Redis OSS**.

   A tela de clusters aparecerá com uma lista de clusters do Valkey ou Redis OSS (modo cluster desabilitado) e Valkey ou Redis OSS (modo cluster habilitado).

1. Para encontrar os endpoints Primário e/ou Leitor do cluster, escolha o nome do cluster (e não o botão à esquerda).  
![\[Imagem: endpoint primário para um cluster do Valkey ou Redis OSS (modo cluster desabilitado)\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/Reader-Endpoint.png)

   *Endpoints primários e leitores para um cluster do Valkey ou Redis OSS (modo cluster desabilitado)*

   Se houver apenas um nó no cluster, não haverá um endpoint primário, e você poderá continuar na próxima etapa.

1. Se o cluster do Valkey ou Redis OSS (modo cluster desabilitado) tiver nós de réplica, você poderá encontrar os endpoints dos nós de réplica do cluster escolhendo o nome do cluster e escolhendo a guia **Nós**.

   A tela de nós aparece com cada nó do cluster, primário e réplicas, listados com seu respectivo endpoint.  
![\[Imagem: endpoints de nó para um cluster do Valkey ou Redis OSS (modo cluster desabilitado)\]](http://docs.aws.amazon.com/pt_br/AmazonElastiCache/latest/dg/images/ElastiCache-Endpoints-Redis-Node.png)

   *Endpoints de nó para um cluster do Valkey ou Redis OSS (modo cluster desabilitado)*

1. Como copiar um endpoint para a área de transferência:

   1. Um endpoint por vez, localize o endpoint que você deseja copiar.

   1. Escolha o ícone de cópia diretamente na frente do endpoint.

   O endpoint agora é copiado para a área de transferência. Para obter informações sobre como usar o endpoint para se conectar a um nó, consulte [Conexão a nós do Memcached](nodes-connecting.md#nodes-connecting.mem).

Um endpoint primário do Valkey ou Redis OSS (modo cluster desabilitado) se assemelha ao seguinte. Há uma diferença, dependendo de a criptografia em trânsito estar ou não habilitada.

**Criptografia em trânsito não habilitada**

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

**Criptografia em trânsito habilitada**

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

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

## Localização de endpoints para um cluster do Valkey ou do Redis OSS (modo cluster habilitado) (console)
<a name="Endpoints.Find.RedisCluster"></a>

O cluster do Valkey ou Redis OSS (modo cluster habilitado) possui um único endpoint de configuração. Ao se conectar ao endpoint de configuração, a aplicação pode descobrir os endpoints primários e os endpoints de leitura para cada fragmento no cluster.

**Para encontrar o endpoint de um cluster do Valkey ou Redis OSS (modo cluster habilitado)**

1. Faça login no Console de gerenciamento da AWS e abra o console do ElastiCache em [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).

1. No painel de navegação, escolha **Clusters do Valkey** ou **Clusters do Redis OSS**.

   A tela de clusters será exibida com uma lista de clusters. Escolha o cluster ao qual você deseja se conectar.

1. Para encontrar o endpoint de configuração do cluster, escolha o nome do cluster (não o botão de opção).

1. O **endpoint de configuração** é exibido em **detalhes do cluster**. Para copiá-lo, selecione o ícone *copiar* à esquerda do endpoint. 

## Localização de endpoints de um cluster (console) (Memcached)
<a name="Endpoints.Find.Memcached"></a>

Todos os endpoints Memcached são endpoints de leitura/gravação. Para se conectar a nós em um cluster Memcached, seu aplicativo pode usar os endpoints para cada nó ou o endpoint de configuração do cluster, juntamente com a Descoberta automática. Para usar a Descoberta automática, você deve usar um cliente que ofereça suporte para Descoberta automática.

Ao usar a Descoberta automática, seu aplicativo cliente se conecta ao seu cluster Memcached usando o endpoint de configuração. À medida que você escalar seu cluster adicionando ou removendo nós, seu aplicativo "conhecerá" automaticamente todos os nós do cluster e poderá se conectar a qualquer um deles. Sem a Descoberta automática, seu aplicativo teria que fazer isso, ou você precisaria atualizar manualmente os endpoints no seu aplicativo sempre que adicionasse ou removesse um nó. 

Para copiar um endpoint, escolha o ícone de cópia diretamente na frente do endereço do endpoint. Para obter informações sobre como usar o endpoint para se conectar a um nó, consulte [Conexão a nós do Memcached](nodes-connecting.md#nodes-connecting.mem).

Endpoints de configuração e de nó são muitos semelhantes. As diferenças estão realçadas com **negrito** a seguir.

```
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**  
Se você optar por criar um CNAME para o seu endpoint de configuração Memcached, para que o seu cliente de descoberta automática reconheça o CNAME como um endpoint de configuração, você deverá incluir `.cfg.` nesse CNAME. 

## Localizar endpoints (AWS CLI)
<a name="Endpoints.Find.CLI"></a>

Para o Memcached, você pode usar a AWS CLI do Amazon ElastiCache para descobrir os endpoints para nós e clusters.

Para o Redis OSS, você pode usar a AWS CLI do Amazon ElastiCache para descobrir os endpoints para nós, clusters e também grupos de replicação.

**Topics**
+ [Encontrar endpoints para nós e clusters (AWS CLI)](#Endpoints.Find.CLI.Nodes)
+ [Localização de endpoints para grupos de replicação do Valkey ou Redis OSS (AWS CLI)](#Endpoints.Find.CLI.ReplGroups)

### Encontrar endpoints para nós e clusters (AWS CLI)
<a name="Endpoints.Find.CLI.Nodes"></a>

Você pode usar a AWS CLI para descobrir os endpoints para um cluster e seus nós com o comando `describe-cache-clusters`. Para clusters do Valkey ou Redis OSS, o comando retorna o endpoint do cluster.  Para clusters Memcached, o comando retorna o endpoint de configuração. Se você incluir o parâmetro opcional `--show-cache-node-info`, o comando também retornará os endpoints dos nós individuais no cluster.

**Example**  
O comando a seguir recupera os endpoints de configuração (`ConfigurationEndpoint`) e os endpoints de nó individuais (`Endpoint`) para o cluster Memcached *mycluster*.  
Para Linux, macOS ou Unix:  

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

```
aws elasticache describe-cache-clusters ^
    --cache-cluster-id mycluster ^
    --show-cache-node-info
```
O resultado da operação acima deve ser semelhante a este (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"
        }
    ]   
}
```
Se você optar por criar um CNAME para o seu endpoint de configuração Memcached, para que o seu cliente de descoberta automática reconheça o CNAME como um endpoint de configuração, você deverá incluir `.cfg.` nesse CNAME. Por exemplo, `mycluster.cfg.local` no seu arquivo php.ini para o parâmetro `session.save_path`.

**Example**  
Para Valkey e Redis OSS, o comando a seguir recupera as informações do cluster para o cluster de nó único *mycluster*.  
O parâmetro `--cache-cluster-id` pode ser usado com um ID de cluster do Valkey ou Redis OSS (modo cluster desabilitado) de nó único ou IDs de nó específicos em grupos de replicação. O `--cache-cluster-id` de um grupo de replicação é um valor de 4 dígitos, como `0001`. Se `--cache-cluster-id` for o ID de um cluster (nó) em um grupo de replicação, o `replication-group-id` será incluído na saída.
Para Linux, macOS ou Unix:  

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

```
aws elasticache describe-cache-clusters ^
    --cache-cluster-id redis-cluster ^
    --show-cache-node-info
```
O resultado da operação acima deve ser semelhante a este (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"
        }
    ]
}
```

Para obter mais informações, consulte o tópico [describe-cache-clusters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html).

### Localização de endpoints para grupos de replicação do Valkey ou Redis OSS (AWS CLI)
<a name="Endpoints.Find.CLI.ReplGroups"></a>

Você pode usar a AWS CLI para descobrir os endpoints para um grupo de replicação e seus clusters com o comando `describe-replication-groups`. O comando retorna o endpoint primário do grupo de replicação e uma lista de todos os clusters (nós) no grupo de replicação com seus endpoints, junto com o endpoint de leitor. 

A seguinte operação recupera o endpoint primário e o endpoint de leitor para o grupo de replicação `myreplgroup`. Use o endpoint primário para todas as operações de gravação. 

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

Para Windows:

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

O resultado dessa operação deve ser semelhante a este (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": {}
      }
   ]
}
```

Para obter mais informações, consulte [describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html) na *Referência de comandos da AWS CLI*.

## Localização de endpoints (API do ElastiCache)
<a name="Endpoints.Find.API"></a>

Para o Memcached, você pode usar a API do Amazon ElastiCache para descobrir os endpoints para nós e clusters.

Para o Redis OSS, você pode usar a API do Amazon ElastiCache para descobrir os endpoints para nós, clusters e também grupos de replicação.

**Topics**
+ [Localização de endpoints para nós e clusters (API do ElastiCache)](#Endpoints.Find.API.Nodes)
+ [Localização de endpoints para grupos de replicação do Valkey ou Redis OSS (API do ElastiCache)](#Endpoints.Find.API.ReplGroups)

### Localização de endpoints para nós e clusters (API do ElastiCache)
<a name="Endpoints.Find.API.Nodes"></a>

Você pode usar a API do ElastiCache para descobrir os endpoints para um cluster e seus nós com a ação `DescribeCacheClusters`. Para clusters do Valkey ou Redis OSS, o comando retorna o endpoint do cluster.  Para clusters Memcached, o comando retorna o endpoint de configuração. Se você incluir o parâmetro opcional `ShowCacheNodeInfo`, a ação também retornará os endpoints dos nós individuais no cluster.

**Example**  
Para o Memcached, o comando a seguir recupera os endpoints de configuração (`ConfigurationEndpoint`) e os endpoints de nó individuais (`Endpoint`) para o cluster do Memcached *mycluster*.  

```
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>
```
Se você optar por criar um CNAME para o seu endpoint de configuração Memcached, para que o seu cliente de descoberta automática reconheça o CNAME como um endpoint de configuração, você deverá incluir `.cfg.` nesse CNAME. Por exemplo, `mycluster.cfg.local` no seu arquivo php.ini para o parâmetro `session.save_path`.

### Localização de endpoints para grupos de replicação do Valkey ou Redis OSS (API do ElastiCache)
<a name="Endpoints.Find.API.ReplGroups"></a>

Você pode usar a API do ElastiCache para descobrir os endpoints para um grupo de replicação e seus cluster com a ação `DescribeReplicationGroups`. A ação retorna o endpoint primário do grupo de replicação e uma lista de todos os clusters no grupo de replicação com seus endpoints, junto com o endpoint de leitor. 

A operação a seguir recupera o endpoint primário (PrimaryEndpoint), o endpoints de leitor (ReaderEndpoint) e os endpoints de nós individuais (ReadEndpoint) para o grupo de replicação `myreplgroup`. Use o endpoint primário para todas as operações de gravação.

```
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>
```

Para obter mais informações, consulte [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html). 