Como implementar warm-up de conexão para reduzir latência na API de CPF

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class CPFClient:
    def __init__(self, api_key):
    self.session = requests.Session()
    self.session.headers.update({
    'x-api-key': api_key,
    'Accept': 'application/json'
    })

    # Configurar pool de conexoes
    adapter = HTTPAdapter(
    pool_connections=5,
    pool_maxsize=10,
    max_retries=Retry(total=3, backoff_factor=0.5)
    )
    self.session.mount('https://', adapter)

    def warm_up(self):
    """Estabelece a conexao antes de precisar."""
    try:
    self.session.get(
    'https://api.cpfhub.io/cpf/00000000000',
    timeout=15
    )
    print('Conexao aquecida com sucesso')
    except Exception as e:
    print(f'Warm-up falhou: {e}')

    def consultar(self, cpf):
    response = self.session.get(
    f'https://api.cpfhub.io/cpf/{cpf}',
    timeout=15
    )
    return response.json()

# Inicializar e aquecer ao subir a aplicacao
client = CPFClient('SUA_CHAVE_DE_API')
client.warm_up()

# Chamadas subsequentes reutilizam a conexao
resultado = client.consultar('12345678900')

const http = require('http');
const https = require('https');

// Agente com keep-alive habilitado
const agent = new https.Agent({
    keepAlive: true,
    keepAliveMsecs: 30000,
    maxSockets: 10,
    maxFreeSockets: 5
});

class CPFClient {
    constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.cpfhub.io';
    }

    async warmUp() {
    try {
    await fetch(`${this.baseUrl}/cpf/00000000000`, {
    method: 'GET',
    headers: {
    'x-api-key': this.apiKey,
    'Accept': 'application/json'
    },
    signal: AbortSignal.timeout(15000),
    agent
    });
    console.log('Conexao aquecida com sucesso');
    } catch (error) {
    console.log(`Warm-up falhou: ${error.message}`);
    }
    }

    async consultar(cpf) {
    const response = await fetch(`${this.baseUrl}/cpf/${cpf}`, {
    method: 'GET',
    headers: {
    'x-api-key': this.apiKey,
    'Accept': 'application/json'
    },
    signal: AbortSignal.timeout(15000),
    agent
    });
    return response.json();
    }
}

const client = new CPFClient(process.env.CPFHUB_API_KEY);
await client.warmUp();

import threading
import time

class CPFClientComKeepAlive(CPFClient):
    def __init__(self, api_key, intervalo_keepalive=60):
    super().__init__(api_key)
    self.intervalo = intervalo_keepalive
    self._iniciar_keepalive()

    def _iniciar_keepalive(self):
    def keepalive_loop():
    while True:
    time.sleep(self.intervalo)
    try:
    self.session.get(
    'https://api.cpfhub.io/cpf/00000000000',
    timeout=15
    )
    except Exception:
    pass # Silenciar erros do keepalive

    thread = threading.Thread(target=keepalive_loop, daemon=True)
    thread.start()

# A conexao permanece quente mesmo em periodos de baixo trafego
client = CPFClientComKeepAlive('SUA_CHAVE_DE_API', intervalo_keepalive=120)

const express = require('express');
const app = express();

let cpfClient;

async function inicializar() {
    cpfClient = new CPFClient(process.env.CPFHUB_API_KEY);
    await cpfClient.warmUp();
    console.log('CPFHub client inicializado e aquecido');
}

app.get('/api/validar/:cpf', async (req, res) => {
    const resultado = await cpfClient.consultar(req.params.cpf);
    res.json(resultado);
});

inicializar().then(() => {
    app.listen(3000, () => console.log('Servidor pronto na porta 3000'));
});

# apps.py
from django.apps import AppConfig

class CpfValidacaoConfig(AppConfig):
    name = 'cpf_validacao'

    def ready(self):
    from .services import cpf_client
    cpf_client.warm_up()

import socket

def pre_resolver_dns(hostname):
    try:
    ip = socket.gethostbyname(hostname)
    print(f'{hostname} -> {ip}')
    return ip
    except socket.gaierror as e:
    print(f'Erro ao resolver DNS: {e}')
    return None

# Resolver na inicializacao
ip_cpfhub = pre_resolver_dns('api.cpfhub.io')

import time

client = CPFClient('SUA_CHAVE_DE_API')

# Primeira chamada (cold)
inicio = time.perf_counter()
client.consultar('12345678900')
latencia_cold = (time.perf_counter() - inicio) * 1000

# Segunda chamada (warm)
inicio = time.perf_counter()
client.consultar('12345678900')
latencia_warm = (time.perf_counter() - inicio) * 1000

print(f'Cold start: {latencia_cold:.2f}ms')
print(f'Warm: {latencia_warm:.2f}ms')
print(f'Economia: {latencia_cold - latencia_warm:.2f}ms')