Encontrando pontos de extremidade de conexão em ElastiCache

Seu aplicativo se conecta ao seu ElastiCache cluster usando endpoints. Um endpoint é o endereço exclusivo de um nó ou cluster.

Quais endpoints usar com Valkey ou Redis OSS

nó autônomo, use o endpoint do nó para operações de leitura e gravação.
Clusters Valkery, Valkey ou Redis OSS (modo de cluster desativado) usam 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 pontos finais individuais do Node para operações de leitura (noAPI//, CLI eles são chamados de pontos finais de leitura).
Clusters Valkey ou Redis OSS (habilitado para o modo de cluster) usam o Endpoint de configuração do cluster para todas as operações que oferecem suporte a comandos habilitados para o modo de cluster. Você deve usar um cliente que ofereça suporte ao Valkey Cluster ou ao Redis OSS Cluster (Redis 3.2OSS). Você ainda pode ler a partir de pontos de extremidade de nós individuais (no API /, CLI eles são chamados de pontos de extremidade de leitura).

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

Quais endpoints usar com o Memcached

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

A partir do AWS CLI, use o describe-serverless-caches comando 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

A saída da operação acima deve ser semelhante a esta (JSONformato):


{
    "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.

Se um cluster Valkery, Valkey ou Redis OSS (modo de cluster desativado) tiver somente um nó, o endpoint do nó será usado para leituras e gravações. Se um cluster Valkery, Valkey ou Redis OSS (modo de cluster desativado) tiver vários nós, haverá três tipos de endpoints: o endpoint primário, o endpoint do leitor e os endpoints do nó.

O endpoint primário é um DNS nome 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 leitura dividirá uniformemente as conexões de entrada com o endpoint entre todas as réplicas de leitura em um cluster ElastiCache (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 as várias réplicas de leitura do seu cluster ElastiCache (RedisOSS) em diferentes zonas de AWS disponibilidade (AZ) para garantir a alta disponibilidade dos endpoints de leitura.

nota

Um endpoint leitor não é um balanceador de carga. É um DNS registro que será resolvido para um endereço IP de um dos nós de réplica de forma redonda.

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 encontrar os endpoints de um cluster Valkery, Valkey ou Redis OSS (modo de cluster desativado)

Faça login no AWS Management Console e abra o ElastiCache console em https://console.aws.amazon.com/elasticache/.
No painel de navegação, escolha clusters Valkey ou clusters Redis OSS.

A tela de clusters aparecerá com uma lista de clusters Valkery, Valkey ou Redis OSS (modo de cluster desativado) e Valkey ou Redis OSS (modo de cluster ativado).
Para encontrar os endpoints Primário e/ou Leitor do cluster, escolha o nome do cluster (e não o botão à esquerda).

Endpoints primários e Reader para um cluster Valkery, Valkey ou Redis OSS (modo de cluster desativado)

Se houver apenas um nó no cluster, não haverá um endpoint primário, e você poderá continuar na próxima etapa.
Se o cluster Valkery, Valkey ou Redis OSS (modo de cluster desativado) tiver nós de réplica, você poderá encontrar os endpoints do nó de réplica do cluster escolhendo o nome do cluster e, em seguida, escolhendo a guia Nodes.

A tela de nós aparece com cada nó do cluster, primário e réplicas, listados com seu respectivo endpoint.

Endpoints de nós para um cluster Valkery, Valkey ou Redis OSS (modo de cluster desativado)
Como copiar um endpoint para a área de transferência:
1. Um endpoint por vez, localize o endpoint que você deseja copiar.
2. 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 Conectando-se aos nós do Memcached.

Um endpoint primário Valkery, Valkey ou Redis OSS (modo de cluster desativado) se parece com o 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

Um cluster Valkey ou Redis OSS (modo de cluster ativado) tem 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 Valkey ou Redis OSS (modo de cluster ativado)

Faça login no AWS Management Console e abra o ElastiCache console em https://console.aws.amazon.com/elasticache/.
No painel de navegação, escolha clusters Valkey ou clusters Redis OSS.

A tela de clusters será exibida com uma lista de clusters. Escolha o cluster ao qual você deseja se conectar.
Para encontrar o endpoint de configuração do cluster, escolha o nome do cluster (não o botão de opção).
O endpoint de configuração é exibido em detalhes do cluster. Para copiá-lo, selecione o ícone copiar à esquerda do endpoint.

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 Conectando-se aos nós do Memcached.

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

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

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

Tópicos

Encontrar endpoints para nós e clusters (AWS CLI)
Encontrando os endpoints para grupos de OSS replicação Valkey ou Redis ()AWS CLI

Encontrar endpoints para nós e clusters (AWS CLI)

Você pode usar o AWS CLI para descobrir os endpoints de um cluster e seus nós com o describe-cache-clusters comando. Para OSS clusters Valkey ou Redis, 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.

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

A saída da operação acima deve ser semelhante a esta (JSONformato).


{
   "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"
        }
    ]   
}

Importante

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

Para Valkey e RedisOSS, o comando a seguir recupera as informações do cluster de nó único mycluster.

Importante

O parâmetro --cache-cluster-id pode ser usado com ID de cluster Valkey ou Redis de nó único OSS (modo de cluster desativado) 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, 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

A saída da operação acima deve ser semelhante a esta (JSONformato).


{
    "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.

Encontrando os endpoints para grupos de OSS replicação Valkey ou Redis ()AWS CLI

Você pode usar o AWS CLI para descobrir os endpoints de um grupo de replicação e seus clusters com o describe-replication-groups comando. 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

A saída dessa operação deve ser semelhante a esta (JSONformato).


{
   "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-groupsna Referência de AWS CLI Comandos.

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

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

Tópicos

Encontrando endpoints para nós e clusters () ElastiCache API
Encontrando endpoints para grupos de OSS replicação Valkey ou Redis () ElastiCache API

Encontrando endpoints para nós e clusters () ElastiCache API

Você pode usar o ElastiCache API para descobrir os endpoints de um cluster e seus nós com a DescribeCacheClusters ação. Para OSS clusters Valkey ou Redis, 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.

Para o Memcached, o comando a seguir recupera o endpoint de configuração (ConfigurationEndpoint) e os endpoints de nós individuais () do cluster do Memcached Endpoint 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>

Importante

Encontrando endpoints para grupos de OSS replicação Valkey ou Redis () ElastiCache API

Você pode usar o ElastiCache API para descobrir os endpoints de um grupo de replicação e seus clusters com a DescribeReplicationGroups ação. 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 endpoint do leitor (ReaderEndpoint) e os endpoints individuais do nó (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.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Acessando seu ElastiCache cluster ou grupo de replicação

Fragmentos em ElastiCache