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

ElastiCache criptografia em trânsito () TLS

Para ajudar a manter seus dados seguros, a Amazon ElastiCache e a Amazon EC2 fornecem mecanismos de proteção contra o acesso não autorizado aos seus dados no servidor. Ao fornecer o recurso de criptografia em trânsito, ElastiCache oferece uma ferramenta que você pode usar para ajudar a proteger seus dados quando eles são movidos de um local para outro.

Todos os caches OSS sem servidor Valkey ou Redis têm a criptografia em trânsito ativada. Para clusters autoprojetados, você pode habilitar a criptografia em trânsito em um grupo de replicação definindo o parâmetro como true (CLI:--transit-encryption-enabled) TransitEncryptionEnabled ao criar o grupo de replicação. Você pode fazer isso se estiver criando o grupo de replicação usando o AWS Management Console AWS CLI, o ou o. ElastiCache API

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

Visão geral da criptografia em trânsito

A criptografia ElastiCache em trânsito da Amazon é um recurso que permite aumentar a segurança de seus dados nos 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.

ElastiCache a criptografia em trânsito implementa os seguintes recursos:

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

As seguintes restrições na criptografia ElastiCache em trânsito da Amazon devem ser lembradas ao planejar sua implementação de cluster autoprojetada:

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

As seguintes restrições na criptografia ElastiCache em trânsito da Amazon devem ser lembradas ao planejar sua implementação de cluster autoprojetada:

Práticas recomendadas de criptografia em trânsito

Outras opções de Valkey e Redis OSS

Para obter mais informações sobre as opções disponíveis para Valkey e RedisOSS, 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 step-by-step processo, consulteCriação de um cluster para Valkey ou Redis OSS.

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

Para acessar dados de quatro nós do ElastiCache Memcached habilitados com criptografia em trânsito, você precisa usar clientes que funcionem 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

Criando um cliente TLS Memcached usando Java

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

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");
    }
}

Criando um cliente TLS Memcached usando PHP

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

<?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 PHP cliente, consulteInstalação do cliente de cluster do ElastiCache para PHP.