Impacto do teste de criptografia SSL no desempenho da instância - ApsaraDB for MongoDB: Central de Documentação do Alibaba Cloud

Para avaliar como a criptografia SSL afeta o desempenho de uma instância do ApsaraDB for MongoDB, meça o tempo de estabelecimento de conexão e a latência de consulta com e sem SSL ativado.

Ambiente de teste

Crie uma instância ECS e uma instância do ApsaraDB for MongoDB. Para mais informações, consulte Criar uma instância de conjunto de réplicas e Criar e gerenciar uma instância ECS no console (versão express).

O teste utiliza as configurações a seguir.

Instância do ApsaraDB for MongoDB
- Arquitetura da instância: instância de conjunto de réplicas
- Quantidade de nós primários e secundários: três nós
- Quantidade de nós somente leitura: um nó
- Especificações da instância: 1 núcleo e 2 GB de memória (uso geral)
- Versão da instância: MongoDB 4.2
Instância ECS
- Tipo de instância: ecs.e-c1m2.large (2 núcleos e 4 GB de memória)

Método de teste

Importar dados de teste

Utilize o Yahoo! Cloud Serving Benchmark (YCSB) para importar 1.000.000 de registros em uma coleção chamada usertable, dentro de um banco de dados chamado ycsb. Execute o comando abaixo para realizar a importação:

./bin/ycsb load mongodb -s -p workload=site.ycsb.workloads.CoreWorkload -p recordcount=1000000 -p mongodb.url="mongodb://root:******@dds-bp103175eafac****.mongodb.rds.aliyuncs.com:3717,dds-bp103175eafac****.mongodb.rds.aliyuncs.com:3717,dds-bp103175eafac****.mongodb.rds.aliyuncs.com:3717/admin?readPreference=secondary&replicaSet=mgset-82894753" -threads 8

A coleção gerada pelo YCSB possui a seguinte estrutura:

{
  "_id": "user1352498093671118016",
  "field1": "BinData(0,\"L1s/KS8+MlYhISUuIz8qNVx9PTRuNiooNlolPVMzJCE0ODNuP15zLjB6NSU4LV0pPC98LkovOFttOyQkL1chNV8tOlxrKlstPkp3IzkiLTcuLU93ITRqOzEwPScsIEx5L1o5JQ==\")",
  "field0": "BinData(0,\"I0I/NDAmNUkrLFA3PEA5IEI3KC4qKEJ1LCc6JV8rJlo7KUR3MDRqMk95KjhoIlUjLy1qMls9OFU7PTpuKTZsNlUpMVYvNSI4KDlwK1trIUpnMlInKSAmNDg8LSpmOl85PkozMA==\")",
  "field7": "BinData(0,\"NzxyPjUkNiYsOEp1MUIpIDA0M1U/JE1nMjMmODhkIko/LEh1NSRqKl1jKDBqJjMqMiw8PSc6KjgsNEwrLFkpKFh9OzQ+MS86LiB4P1oxLVxjIiQgMCdsM0AhO0QzNTFqI1dpMw==\")",
  "field6": "BinData(0,\"MVhpIj1uI0RlJ1AtP0t/LkAxMVp9MlU3KFJpK0Z3M0M/OE55IFBhPyA6Njp+L1tnJjh4Iic4K1F/Oi9gKz44PFFpPE5jNydqKUJrPyV4KDY2LDd0Nic6PC9wPDhgNykwOj10Iw==\")",
  "field9": "BinData(0,\"OEA/NDRwLilwLzVoMz5oIzVuLStoPlF9NVU5MVd3PDUkPV0nPl07OU05LkYnKDQ8L0VrIkwlJDg+NCRuIitoNjV4PkM9NCt0LyE4PCFkKUI/LVwxKjdsMkgnICsgKFQrJit8Lg==\")",
  "field8": "BinData(0,\"P0J/P0ozMCBwIjJwP0IpJUMlPkhhIkI3MU91OjUmMFM9NEBhJD8+OEdpJDh2OyxmMCQkKUgnJjYoKC0kKVMnKTQuODp6JjVwKSRwI1FhJy88PVAhPiE2OCMsKlYvJF1xOEUrJA==\")",
  "field3": "BinData(0,\"Mjc6KE4zJTEuJCJ4P18lNCZ4NkAtKTAwLFUvMDEsOzUkIEs3MVEzKT4mL1Q5IVF9N0N3O1snIUZ1L0k9IUY7IV8nNiQ+KTJ0I097Llg1MjE0PCQ4KDV2KzYsIDtwNzhuKkQrMA==\")",
  "field2": "BinData(0,\"Jit6L0olLTByJzpuPygyKSE8Li9iK00xIig4PVQhKTBqLkI/O0N9Izs+NVk/ISVmIy14Nko3NyxoI1Z1Pyo4JVt/MylsK1t9PS9yP1kzJFMjPF43P1l5P1xtPDAqLF57IiAsPQ==\")",
  "field5": "BinData(0,\"NSd2NiskPzcmITU4Oz58NzliP0ZpOz5wKiI0OVhlNDx0PlV1OllnNzJiOyMmOF45IEg7OD90KUZnP0g5OUJzK0M/OyN4O15lPzA6LTUgNUw9NDVoL0QrOTssISQ2KCw6KUJlKg==\")",
  "field4": "BinData(0,\"NDNkKjFuPyxsJzEmNzMqLVJzL0YpMTNwMjs8MTRiNEYtLE05P0I9NEU1LS4yNEFpNjUsOUs9JEs1IU5jOF5vIjpiNTMuKSY6K0s1LDp2JEp9KyFiIS1+J1U/LkoxMEp5OzJiIw==\")"
}

Executar um script de teste

Como o YCSB não suporta testes de estresse com criptografia SSL ativada, utilize o script Python a seguir como alternativa.

import time
import pymongo
import datetime
import logging as log
from functools import wraps

log.basicConfig(
    level=log.INFO, format='%(asctime)s - [line %(lineno)d] : %(levelname)s - %(message)s')
console = log.StreamHandler()
console.setLevel(log.INFO)
formatter = log.Formatter(
    '%(asctime)s - [line %(lineno)d] : %(levelname)s - %(message)s')
console.setFormatter(formatter)

def time_recorder():
    def inner(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            start_time = time.time()
            result = func(*args, **kwargs)
            end_time = time.time()
            elapsed_time = (end_time - start_time) * 1000

            print_latency = kwargs.get("print_latency", False)
            return_latency = kwargs.get("return_latency", False)

            if print_latency:
                log.info(
                    f"Function {func.__name__} took {elapsed_time:.4f} millseconds to execute.")

            if return_latency:
                return result, elapsed_time
            return result
        return wrapper
    return inner

@time_recorder()
def build_client_without_ssl(**kwargs):
    client = pymongo.MongoClient(
        "mongodb://root:******@dds-bp103175eafac****.mongodb.rds.aliyuncs.com:3717,dds-bp103175eafac****.mongodb.rds.aliyuncs.com:3717,dds-bp103175eafac****.mongodb.rds.aliyuncs.com:3717/admin?readPreference=secondary&replicaSet=mgset-82894753")
    return client

@time_recorder()
def build_client_with_ssl(**kwargs):
    client = pymongo.MongoClient(
        "mongodb://root:******@dds-bp103175eafac****.mongodb.rds.aliyuncs.com:3717,dds-bp103175eafac****.mongodb.rds.aliyuncs.com:3717,dds-bp103175eafac****.mongodb.rds.aliyuncs.com:3717/admin?readPreference=secondary&replicaSet=mgset-82894753&tls=true&tlsAllowInvalidHostnames=true&tlsCAFile=/root/ApsaraDB-CA-Chain.pem")
    return client

@time_recorder()
def find_one(client, **kwargs):
    client["ycsb"]["usertable"].find_one()

def test_connection():
    client = build_client_without_ssl(print_latency=True)
    find_one(client)

    client = build_client_with_ssl(print_latency=True)
    find_one(client)

test_connection()

@time_recorder()
def test(with_ssl=False, repeat=5000, **kwargs):
    log.info(f"test, with_ssl: {with_ssl}, repeat: {repeat}")
    ssl_suffix = "without-ssl"
    if with_ssl:
        ssl_suffix = "with-ssl"
    suffix = f"{repeat}-{ssl_suffix}.log"
    only_connection_file = f"only-connection-{suffix}"
    first_query_file = f"first-query-{suffix}"
    connection_and_first_query_file = f"connection-and-first-query-{suffix}"

    only_connection_f = open(only_connection_file, 'w')
    first_query_f = open(first_query_file, 'w')
    connection_and_first_query_f = open(connection_and_first_query_file, 'w')

    for _ in range(repeat):
        client = None
        connection_latency = 0

        if with_ssl:
            client, connection_latency = build_client_with_ssl(
                return_latency=True)
        else:
            client, connection_latency = build_client_without_ssl(
                return_latency=True)

        _, query_latency = find_one(client, return_latency=True)

        only_connection_f.write(f"{connection_latency}\n")
        first_query_f.write(f"{query_latency}\n")
        connection_and_first_query_f.write(f"{connection_latency + query_latency}\n")

    only_connection_f.close()
    first_query_f.close()
    connection_and_first_query_f.close()

    log.info(f"test end, write to {only_connection_file}, {first_query_file} and {connection_and_first_query_file}")

test(False, 5000, print_latency=True)
test(True, 5000, print_latency=True)

@time_recorder()
def run(client, log_file, repeat=5000, **kwargs):
    start = time.time()
    log.info(f"start to query, repeat: {repeat}")

    with open(log_file, 'w') as f:
        for _ in range(repeat):
            latency = find_one(client, return_latency=True)
            f.write(f"{latency}\n")

    end = time.time()
    total = (end - start) * 1000
    avg = total / repeat
    log.info(
        f"end query, repeat: {repeat}, total: {total} millseconds, avg: {avg} millseconds")

client = build_client_without_ssl()
run(client, "without-ssl.log")

client = build_client_with_ssl()
run(client, "with-ssl.log")

Modifique os parâmetros abaixo conforme necessário:

client: Substitua a string de conexão, o nome de usuário e a senha em pymongo.MongoClient() pelos valores reais da sua instância do ApsaraDB for MongoDB.
repeat: Defina o número de iterações do teste. O valor padrão é 5.000, mas você pode alterá-lo conforme sua necessidade.

O script gera as seguintes métricas:

only-connection: Tempo gasto para estabelecer a conexão.
first-query: Duração da primeira consulta após o estabelecimento da conexão.
connection-and-first-query: Tempo total decorrido desde o início da conexão até a conclusão da primeira consulta. Corresponde à soma de only-connection e first-query.
latency: Duração média de 5.000 consultas ao reutilizar o cliente especificado por pymongo.MongoClient().

Resultados do teste

A tabela a seguir apresenta os valores médios obtidos em 5.000 iterações.

Item	Tempo consumido com criptografia SSL desativada (ms)	Tempo consumido com criptografia SSL ativada (ms)
Tempo para estabelecer conexão	3,7009	19,8515
Duração da primeira consulta após o estabelecimento da conexão	20,7456	43,5884
Tempo total desde o estabelecimento da conexão até a conclusão da primeira consulta	24,4465	63,4399
Duração média da consulta ao reutilizar o cliente especificado	0,7506	0,7643

A diferença de desempenho entre conexões com e sem SSL ocorre principalmente durante o estabelecimento da conexão. Ao reutilizar conexões existentes, as durações médias das consultas são praticamente idênticas. Os principais motivos são:

O Transport Layer Security (TLS) adiciona tempo extra de ida e volta (RTT) durante o estabelecimento da conexão.

Com o pool de conexões, essa sobrecarga de RTT é diluída entre as conexões. Reutilizar um cliente existente após ativar o SSL minimiza a sobrecarga do handshake TLS.
A criptografia e descriptografia SSL adicionam sobrecarga a cada mensagem transmitida por uma conexão já estabelecida.

CPUs modernas processam criptografia e descriptografia rapidamente. Outros fatores, como E/S de disco e espera em fila, consomem mais tempo durante uma consulta, tornando o impacto de desempenho da criptografia relativamente pequeno.