Criptografia em trânsito (TLS) do ElastiCache

Para ajudar a manter seus dados seguros, o Amazon ElastiCache e o Amazon EC2 fornecem mecanismos para proteger contra o acesso não autorizado aos seus dados no servidor. Ao fornecer a capacidade de criptografia em trânsito, o ElastiCache oferece uma ferramenta que pode ser usada para ajudar a proteger seus dados durante sua movimentação de um local para outro.

Todos os caches de tecnologia sem servidor do Valkey ou Redis OSS têm criptografia em trânsito habilitada. Para clusters baseados em nós, você pode habilitar a criptografia em trânsito em um grupo de replicação configurando o parâmetro TransitEncryptionEnabled como true (CLI: --transit-encryption-enabled) ao criar o grupo de replicação. Isso pode ser feito ao criar o grupo de replicação usando o Console de gerenciamento da AWS, a AWS CLI ou a API do ElastiCache.

Todos os caches sem servidor têm criptografia em trânsito habilitada. Para clusters baseados em nós, você pode habilitar a criptografia em trânsito em um cluster definindo o parâmetro como TransitEncryptionEnabled (trueCLI: --transit-encryption-enabled) ao criar o cluster usando a operação CreateCacheCluster (CLI: create-cache-cluster).

Visão geral da criptografia em trânsito

A criptografia em trânsito do Amazon ElastiCache é um recurso que permite aumentar a segurança de seus dados em seus pontos mais vulneráveis: quando estão em trânsito de um local para outro. Como a criptografia e descriptografia dos dados requerem processamento nos endpoints, a ativação da criptografia em trânsito pode ter impacto no desempenho. Compare seus dados com e sem criptografia em trânsito para determinar o impacto no desempenho para seus casos de uso.

A criptografia em trânsito do ElastiCache implementa os seguintes recursos:

Condições de criptografia em trânsito (Valkey e Redis OSS)

Lembre-se das seguintes restrições de criptografia em trânsito do Amazon ElastiCache quando você planejar sua implementação de cluster baseado em nós:

Condições de criptografia em trânsito (Memcached)

Lembre-se das seguintes restrições de criptografia em trânsito do Amazon ElastiCache quando você planejar sua implementação de cluster baseado em nós:

Práticas recomendadas de criptografia em trânsito

Outras opções para Valkey e Redis OSS

Para obter mais informações sobre as opções disponíveis para Valkey e Redis OSS, consulte os links a seguir.

Habilitação da criptografia em trânsito para o Memcached

Para ativar a criptografia em trânsito ao criar um cluster Memcached usando o AWS Management Console, escolha as seguintes opções:

Para o processo passo a passo, consulte Criação de um cluster do Valkey ou Redis OSS.

Conectar-se a nós habilitados com criptografia em trânsito usando o Openssl (Memcached)

Para acessar dados dos nós do ElastiCache para Memcached habilitados com criptografia em trânsito, use clientes que trabalhem com Secure Socket Layer (SSL). Também é possível usar a Openssl s_client no Amazon Linux e no Amazon Linux 2.

Para usar a Openssl s_client para se conectar a um cluster Memcached habilitado com criptografia em trânsito no Amazon Linux 2 ou no Amazon Linux:

/usr/bin/openssl s_client -connect memcached-node-endpoint:memcached-port

Criação de um cliente TLS Memcached usando Java

Para criar um cliente no modo TLS, faça o seguinte para inicializar o cliente com o SSLContext apropriado:

import java.security.KeyStore;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import net.spy.memcached.AddrUtil;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.MemcachedClient;
public class TLSDemo {
    public static void main(String[] args) throws Exception {
        ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder();
        // Build SSLContext
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init((KeyStore) null);
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, tmf.getTrustManagers(), null);
        // Create the client in TLS mode
        connectionFactoryBuilder.setSSLContext(sslContext);
        MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster.fnjyzo.cfg.use1.cache.amazonaws.com:11211"));

        // Store a data item for an hour.
        client.set("theKey", 3600, "This is the data value");
    }
}

Criação de um cliente TLS Memcached usando PHP

Para criar um cliente no modo TLS, faça o seguinte para inicializar o cliente com o SSLContext apropriado:

<?php

/**
 * Sample PHP code to show how to create a TLS Memcached client. In this example we
 * will use the Amazon ElastiCache Auto Descovery feature, but TLS can also be
 * used with a Static mode client. 
 * See Using the ElastiCache Cluster Client for PHP (https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/AutoDiscovery.Using.ModifyApp.PHP.html) for more information 
 * about Auto Discovery and persistent-id.
 */

/* Configuration endpoint to use to initialize memcached client.
 * this is only an example */
$server_endpoint = "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";

/* Port for connecting to the cluster. 
 * This is only an example     */
$server_port = 11211;

/* Initialize a persistent Memcached client and configure it with the Dynamic client mode  */
$tls_client =  new Memcached('persistent-id');
$tls_client->setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE);

/* Add the memcached's cluster server/s */
$tls_client->addServer($server_endpoint, $server_port);

/* Configure the client to use TLS */
if(!$tls_client->setOption(Memcached::OPT_USE_TLS, 1)) {
    echo $tls_client->getLastErrorMessage(), "\n";
    exit(1);
}

/* Set your TLS context configurations values.
 * See MemcachedTLSContextConfig in memcached-api.php for all configurations */
$tls_config = new MemcachedTLSContextConfig();
$tls_config->hostname = '*.mycluster.fnjyzo.use1.cache.amazonaws.com';
$tls_config->skip_cert_verify = false;
$tls_config->skip_hostname_verify = false;

/* Use the created TLS context configuration object to create OpenSSL's SSL_CTX and set it to your client.
 * Note:  These TLS context configurations will be applied to all the servers connected to this client. */
$tls_client->createAndSetTLSContext((array)$tls_config);

/* test the TLS connection with set-get scenario: */

 /* store the data for 60 seconds in the cluster.
 * The client will decide which cache host will store this item.
 */
if($tls_client->set('key', 'value', 60)) {
    print "Successfully stored key\n";
} else {
    echo "Failed to set key: ", $tls_client->getLastErrorMessage(), "\n";
    exit(1);
}

/* retrieve the key */
if ($tls_client->get('key') === 'value') {
    print "Successfully retrieved key\n";
} else {
    echo "Failed to get key: ", $tls_client->getLastErrorMessage(), "\n";
    exit(1);
}

Para obter mais informações sobre como usar o cliente PHP, consulte Instalação do cliente de cluster do ElastiCache para PHP.