Simulação de balanceamento de mensagem transacional

Diariamente o número de requisições processadas por uma instituição financeira é relevantemente maior que instituições de outro ramo. Por isso, estas empresas necessitam de um investimento maior em tecnologia. Para garantir segurança, disponibilidade e agilidade.
E nessa necessidade de fazer o diferencial aos clientes, encontramos produtos inovadores, mas que às vezes trazem limitações, seja ela de software ou hardware.
Num ambiente transacional, devemos aproveitar todos os recursos que os produtos nos trazem. E pensando nisso, há um bom tempo, com essa necessidade de aproveitar melhor os servidores das instituições financeiras, surgiu a ideia de interoperar F5 e Servidores finais.

Hoje, o F5 BIGIP é um equipamento essencial para aumentar performance e manusear de forma inteligente estas aplicações.

Atualmente temos clientes que utilizam do F5 BIGIP, seu processamento e inteligência, para manusear as aplicações baseadas na ISO8583 (Financial transaction card originated messages — Interchange message specifications) e/ou nas mensagens de HSM (Hardware Secure Module).

O artigo mostrará como, montar um laboratório de maquinas virtuais para simular este ambiente transacional, de forma rápida e prática.
Pré requisitos para o ambiente virtual:

Linux (com pacote perl)
BIGIP LTM VE (a partir da versão 11.5.1)

Configuração do servidor

use IO::Socket::INET;# auto-flush on socket
$| = 1;# creating a listening socket
my $socket = new IO::Socket::INET (
LocalHost => '0.0.0.0',
LocalPort => '7777',
Proto => 'tcp',
Listen => 5,
Reuse => 1
);
die "cannot create socket $!\n" unless $socket;
print "server waiting for client connection on port 7777\n";while(1)
{
# waiting for a new client connection
my $client_socket = $socket->accept();# get information about a newly connected client
my $client_address = $client_socket->peerhost();
my $client_port = $client_socket->peerport();
print "connection from $client_address:$client_port\n";# read up to 1024 characters from the connected client
my $data = "";
$client_socket->recv($data, 1024);
print "received data: $data\n";# write response data to the connected client
#$data = "";
$client_socket->send($data);# notify client that response has been sent
shutdown($client_socket, 1);
}$socket->close();

Script original: http://xmodulo.com/how-to-write-simple-tcp-server-and-client-in-perl.html
Podemos utilizar scripts de servidores em vários tipos de linguagem, vai depender da necessidade. Para este lab, basta um script em Perl.
Este script irá responder com o mesmo valor que foi recebido do script cliente.

Iremos criar dois scripts, um “ouvindo” na porta 7777 e outro na porta 8888. Assim criaremos dois serviços diferentes num mesmo servidor.

1 – Crie uma cópia do script, em seguida modifique a porta:

cat tcpserver1.pl | sed s/7777/8888/g > tcpserver2.pl

2 – Dê permissão aos scripts:

chmod u+rx tcpserver1.pl tcpserver2.pl

3 – Execute os scripts em background:

perl tcpserver1.pl &
perl tcpserver2.pl &

Em execução, ficarão como abaixo:

Configuração do cliente

O cliente TCP que utilizaremos, também foi escrito em perl.

use IO::Socket::INET;
# auto-flush on socket
$| = 1;

# create a connecting socket
my $socket = new IO::Socket::INET (
PeerHost => '192.168.159.132',
PeerPort => '1500',
Proto => 'tcp',
);
die "cannot connect to the server $!\n" unless $socket;
print "connected to the server\n";

# data to send to a server
my $req = '1234567890';
my $size = $socket->send($req);
print "sent data of length $size\n";

# notify server that request has been sent
shutdown($socket, 1);

# receive a response of up to 1024 characters from server
my $response = "";
$socket->recv($response, 1024);
print "received response: $response\n";

$socket->close();

Script original: http://xmodulo.com/how-to-write-simple-tcp-server-and-client-in-perl.html
1 – Coloque o script no servidor Linux e dê permissão de execução:

Chmod u+rx tcpclient.pl
2- Devemos alterar as linhas 8 e 9, IP e porta, respectivamente. Deve-se colocar o IP e Porta do virtual server do F5.
Na linha 16 é especificado a string de dados que o cliente irá enviar ao F5. Podemos colocar qualquer valor dentro das aspas simples. Pois o servidor deverá nos responder com o mesmo valor que ele receber.

As imagens abaixo refletem um teste ao endereço de destino do próprio servidor Linux na porta 7777.

No script tcpclient.pl (cliente), vimos que ele se conectou ao servidor, enviou uma string de 10 caracteres e recebeu a resposta:

No script tcpserver1.pl (servidor), vimos que ele recebeu a string de 10 caracteres corretamente:

Configuração da aplicação no F5 BIGIP

Criar Virtual Server básico, contendo:

– Modo Standard

Este tipo de VS trata a conexão na camada de aplicação, com isso podemos abrir o pacote e modificar as informações. Sem ele não conseguimos colocar o profile de MBLB.

– Profile TCP

Proflie MBLB requer um profile TCP.

– Profile MBLB

Necessário para fazer o balanceamento das mensagens, a irule requer o profile. Este profile só é adicionado via TMSH.

create ltm profile mblb profile_mblb
modify ltm virtual VS_MBLB profiles replace-all-with { profile_mblb }


– Pool com o enredeço IP e Porta do servidor
– Irule

Irule é a inteligência do processo. É por ela que definimos o que fazer com as mensagens.

A irule abaixo lê o payload TCP, calcula o tamanho deste e libera aos servidores, um caractere por vez.

# Copyright (c) 1991-2015 Agility Networks
# irule_mblb_example - v20150318a - Fabio Souza
# fabio.souza@agilitynetworks.com.br
when RULE_INIT {
}

when CLIENT_ACCEPTED {
# Unique mblb context id
set context_id [virtual name]
#Collect payload
TCP::collect
}

when CLIENT_DATA {
# write tcp payload value on variable
binary scan [TCP::payload] a* clientdata
# create a message ID
set keytag_clt $clientdata
# tcp payload length
set length [TCP::payload length]
set i 0

while { $i < $length } {

set c [substr $clientdata $i 1]
log local0. "Msg: $c"
TCP::payload replace 0 [TCP::payload length] ""
TCP::payload replace 0 0 [binary format a* $c]
LB::src_tag $c
# send message
TCP::release 1
TCP::notify eom
incr i
}

}

when SERVER_CONNECTED

{
TCP::collect
}


when SERVER_DATA {
# write tcp payload value on variable
binary scan [TCP::payload] a* serverdata
# create a message ID
set keytag_srv $serverdata
# tcp payload length
set length [TCP::payload length]
set i 0
while { $i < $length } {

set s [substr $serverdata $i 1]
log local0. "Msg: $s"
TCP::payload replace 0 [TCP::payload length] ""
TCP::payload replace 0 0 [binary format a* $s]
LB::src_tag $s
# send message
TCP::release 1
TCP::notify eom
incr i
}

}

A irule abaixo coleta o payload TCP completo, analisa o número de caracteres e envia um caractere por

No arquivo de configuração do F5, a aplicação será parecida com esta:

Virtual Server


root@(bigip1)(cfg-sync Standalone)(Active)(/Common)(tmos)# list ltm virtual vs_mblb_example
ltm virtual vs_mblb_example {
destination 192.168.159.133:vlsi-lm
ip-protocol tcp
mask 255.255.255.255
pool pool_mblb_example
profiles {
profile_mblb { }
profile_tcp { }
}
rules {
irule_mblb_example
}
source 0.0.0.0/0
source-address-translation {
type automap
}
vlans {
vlan_interna_host_only
}
vlans-enabled
vs-index 6
}

Pool

ltm pool pool_mblb_example { members {
opensuse1:cbt {
address 192.168.159.128
session monitor-enabled
state up
}
opensuse1:8888 {
address 192.168.159.128
session monitor-enabled
state up
}
}
monitor tcp
}

Balanceando mensagens de transação no F5 BIGIP

Os testes abaixo mostram o balanceamento de mensagens sendo executado pelo F5. No teste anterior os 10 caracteres enviados pelo cliente foram todos para um só serviço/servidor (o de porta 7777). Desta vez, com a conexão passando pelo F5, a Irule e o profile MBLB irão, juntos, “quebrar” a string e balancear cada caractere para os servidores.

Em seu lab, as evidências deverão parecer com estas abaixo:

Script enviando a requisição para o F5:

Scripts servidores recebendo as requisições já balanceadas:

005

Estatísticas de balanceamento no F5 (Virtual Server e Pool)

No virtual server, há somente uma conexão, pois utilizamos um só script cliente.

Já no Pool, vemos duas conexões, sendo uma para cada servidor. E 5 requisições para cada servidor, comprovando que os caracteres foram balanceados com sucesso.

007

Logs da irule no /var/log/ltm:

Vimos que com poucas configurações podemos balancear mensagens num cenário virtual. Esse laboratório pode ser melhorado conforme a necessidade. Pode-se, por exemplo, simular um ambiente de ISO8583 quase fielmente, aprofundando os estudos de TCL/TK, ISO8583,etc.