Sistemas Distribuídos

Sistemas Distribuídos
Aula 06 – Programação Distribuída
Prof. Hélio de Sousa Lima Filho
([email protected])
Referencial Bibliográfico
• Coulouris, George; Dollimore, Jean e
Kindberg, Tim. Sistemas Distribuídos:
conceitos e projeto.
• Ribeiro, Uirá. Sistemas Distribuídos,
Desenvolvendo aplicações de Alta
Performance no Linux.
Sistemas Distribuídos
2
Programação
Distribuída
• Motivação:
– Avanços na tecnologia de redes e de microprocessadores
• Vantagens (sobre sistemas centralizados):
–
–
–
–
–
Econômica
Desempenho
Algumas aplicações são inerentemente distribuídas
Confiabilidade e tolerância a falhas
Escalabilidade
• Desvantagens:
– Complexidade de desenvolvimento
– Rede
– Segurança
Sistemas Distribuídos
3
Computação Paralela x
Computação Distribuída
• Computação Paralela
– Comunicação via memória compartilhada ou troca de
mensagens
– Objetivo: aumentar throughput (vazão) ou reduzir
tempo de serviço
• Computação Distribuída:
– Comunicação via troca de mensagens
– Troca de mensagens tem custo não desprezível,
além de sujeita a falhas e atrasos
– Nenhum nodo tem conhecimento do estado global do
sistema em um dado instante
– Objetivo: compartilhar recursos fisicamente
separados
Sistemas Distribuídos
4
Algoritmos Distribuídos
• Características:
– Nenhum nodo tem acesso ao estado
completo do sistema
– Nodos tomam decisões baseadas em seu
estado local
– Comunicação via troca de mensagens
– Falha de um nodo não aborta o algoritmo
– Não assume-se existência de um relógio
global
Sistemas Distribuídos
5
Comunicação entre Processos
em Sistemas Distribuídos
• Comunicação em Sistemas:
– Monolíticos: funções, variáveis globais etc
– Distribuídos: troca de mensagens
• Troca de Mensagens:
– Conceito primitivo e de muito baixo nível
– Primitivas send e receive
– Modalidades de Comunicação:
• Síncrona
• Assíncrona
Sistemas Distribuídos
6
Troca de Mensagens:
Marshalling
• Marshalling (“empacotamento”):
preparação de um conjunto de dados para
transmissão em mensagens
• Exemplo:
//nome= “José”, conta= 152, saldo= 25.2
msg:= new Msg;
msg.addField.asString (nome);
msg.addField.asInteger (conta);
msg.addField.asFloat (saldo);
msg.send (Q);
Sistemas Distribuídos
7
Troca de Mensagens:
Unmarshalling
• Unmarshalling (“desempacotamento”): recuperação
de um conjunto de dados enviados em mensagens
msg:= new Msg;
msg.receive (P);
nome= msg.getField.asString ();
conta= msg.getField.asInteger ();
saldo= msg.getField.asFloat ();
• Marshalling e Unmarshalling manuais: tedioso
• Marshalling e Unmarshalling automáticos requer:
– Linguagem para especificação das mensagens
– Compilador para esta linguagem
Sistemas Distribuídos
8
Comunicação Síncrona
• Síncrona: send e receive bloqueantes
– Processo que emitiu send permanece bloqueado
até que outro processo execute receive.
– Processo que emitiu receive permanece
bloqueado até a chegada de uma mensagem
• Vantagem:
– Simplicidade de programação
• Desvantagem:
– Desempenho (CPU fica bloqueada durante
transmissão e recepção)
– Possível solução: múltiplas threads
Sistemas Distribuídos
9
Comunicação Assíncrona
• Assíncrona: send e receive não bloqueantes
– Processo que emitiu send prossegue execução assim que
a mensagem é copiada para um buffer local
– Processo que emitiu receive prossegue execução mesmo
que não exista mensagem.
• receive fornece o endereço de um buffer que será preenchido
em background.
• Processo é notificado da chegada de uma mensagem via
polling ou via interrupção
• Vantagem: melhor desempenho (processamento
durante transmissão e recepção)
• Desvantagem: tratamento do recebimento de
mensagens é mais complexo (ocorre fora do fluxo
normal de execução)
Sistemas Distribuídos
10
Comunicação entre Processos
em Sistemas Distribuídos
• Abstrações de nível mais alto (“middleware”):
–
–
–
–
RPC
CORBA
Java RMI
Microsoft DCOM
• Motivação:
– Troca de mensagens é pouco natural
– Abstrações de mais alto nível para “esconder”
troca de mensagens
Sistemas Distribuídos
11
RPC
• RPC: Chamada Remota de Procedimento
– Birrel & Nelson, 1984
– Protocolo de Apresentação (nível 6)
• Arquitetura: Utilização de stubs
– Client Stub
– Server Stub
• Automatização do processo de
marshalling e unmarshalling
Sistemas Distribuídos
12
RPC
Seqüência de Passos
• Passo 1: Chamada local soma (x, y)
• Passo 2: Stub do cliente “captura” chamada
e realiza o marshalling de seus parâmetros
• Passo 3: Envio de mensagem com os
parâmetros pela rede
• Passo 4: Recebimento da mensagem na
máquina remota e chamada ao stub do
servidor
• Passo 5: Stub do servidor realiza o
unmarshalling dos parâmetros e chama o
procedimento remoto
Sistemas Distribuídos
13
RPC
Seqüência de Passos
• Passo 6: Execução do procedimento remoto
• Passo 7: Stub do servidor realiza o
marshalling do resultado
• Passo 8: Envio da mensagem com o
resultado pela rede
• Passo 9: Recebimento do resultado e chama
stub do cliente
• Passo 10: Stub do cliente realiza o
unmarshalling do resultado e retorna o
mesmo ao cliente
Sistemas Distribuídos
14
RPC
Semântica das Chamadas
• Normalmente, o stub do cliente retransmite
uma mensagem após um certo time-out
• Como então determinar quantas vezes o
procedimento remoto é executado ?
– Uma vez: quando tudo funciona corretamente
– Zero vezes: quando a mensagem do cliente não
chega ao servidor, apesar das várias
retransmissões
– Mais de uma vez: quando a resposta do servidor
se perde
Sistemas Distribuídos
15
RPC
Semântica de Chamadas
• Tipos de semânticas em chamadas RPC:
– Exactly Once
(“exatamente uma vez”):
• Desejada, mas difícil de conseguir
– At Least Once
(“pelo menos uma vez”):
• Basta que cliente tente até conseguir
• RP pode ser executado mais de uma vez
– At Most Once
(“no máximo uma vez”)
• RP pode ser executado 0 ou uma vez
Sistemas Distribuídos
16
Implementação de
Chamadas At Most Once
• Cada chamada RPC possui um identificar
• Servidor armazena em um cache os
identificadores das chamadas que já
foram processadas e os resultados das
mesmas
• Em caso de duplicação, RPC não é
executado de novo e envia-se o resultado
armazenado no cache
• Usado no Sun RPC
Sistemas Distribuídos
17
RPC
Tipos de Operações
• Operações Idempotentes:
– Podem ser executadas qualquer número de
vezes, pois não tem efeito colateral
– Exemplo: consultas em geral (hora, saldo etc)
– Semântica at least once
• Operações Não Idempotentes:
– Possuem efeito colateral.
– Exemplo: atualizações (transferência bancária,
gravação de um registro etc)
– Semântica exactly once
Sistemas Distribuídos
18
Java RMI
• RMI: Invocação Remota de Métodos
– Solução da Sun para desenvolvimento de aplicações
distribuídas em Java
– Permite que programas executando em uma JVM
chamem métodos de objetos localizados em outra JVM
• Registry: objeto remoto que mapeia nomes em
referências para objetos
– rmiregistry: String  referência para objeto
– Todo servidor deve possuir seu registry
• Principais funções:
– rebind: associa um nome a um objeto remoto
– lookup: retorna uma referência para um objeto remoto
Sistemas Distribuídos
19
Java RMI
Stub e Skeleton
• Equivalente a stubs do cliente e do servidor
em RPC
– Stub: parte que executa no cliente
– Skeleton: parte que executa no servidor
• rmic: compilador usado para gerar stub e
skeleton
• Stub é instalado em um diretório especial do
servidor e é buscado automaticamente pelos
clientes, via HTTP ou sistema de arquivos
Sistemas Distribuídos
20
Exemplo de Aplicação
Distribuída Usando Java RMI
• Codificar um servidor com um objeto da
seguinte classe
public class ContaImpl .... { ......
public float obterSaldo ();
........
}
• Codificar um cliente que chame remotamente
o método obterSaldo() deste objeto
Sistemas Distribuídos
21
Java RMI
1: Definição da Interface Remota
• Interface Remota: relaciona os métodos
que serão invocados remotamente
// arquivo Conta.java
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface Conta extends Remote { ......
public float obterSaldo () throws RemoteException; ......
}
Sistemas Distribuídos
22
Java RMI - 2: Implementação
da Interface Remota
• Uma interface remota é implementada por uma classe
// arquivo ContaImpl.java
import java.rmi.*
import java.rmi.server.*;
public class ContaImpl extends UnicastRemoteObject
implements Conta {
private int numero;
private float saldo= 0.0;
Sistemas Distribuídos
23
Java RMI - 2: Implementação
da Interface Remota
public ContaImpl (int n)
{ numero= n; super(); }
public float obterSaldo () throws RemoteException
{ return saldo; }
public static void main (String[] args) {
Conta c= new ContaImpl (804);
Naming.rebind (“Conta804”, c);
}
Sistemas Distribuídos
24
Java RMI
3: Implementação do Cliente
// arquivo ClienteImpl.java
import java.rmi.*
import java.rmi.server.*;
public class ClienteImpl {
public static void main (String[] args) { ......
Conta c= (Conta) Naming.lookup
(“//”+args[0]+“/Conta804”);
float s= c.obterSaldo();
// chamada remota
...... }
}
Sistemas Distribuídos
25
Java RMI
4: Compilação
• Compilação:
javac Conta.java
// Interface
javac ContaImpl.java // Servidor
javac ClienteImpl.java // Cliente
• Geração de stubs:
rmic ContaImpl.java
• rmic gera os seguintes arquivos:
ComtaImpl_Stub.class: stub do cliente
ContaImpl_Skel.class: skeleton (servidor)
Sistemas Distribuídos
26
Java RMI
5: Execução
• Execução do Servidor
start /min rmiregistry
start java contaImpl
// registry
// servidor
• Execução do Cliente
java clienteImpl una_maq01
•
Observação: Alguns parâmetros de linha de comando foram omitidos
nestes exemplos. Os comandos completos podem ser obtidos consultando
o RMI Tutorial.
Sistemas Distribuídos
27
Java RMI
Passagem de Parâmetros
• Objetos podem ser passados como
parâmetros, utilizando passagem por valor
– Basta que implementem a interface
Serializable
• Carregamento Dinâmico de Código:
– Se o código da classe de um objeto não
estiver disponível na JVM para onde o objeto
foi enviado, o mesmo é carregado
dinamicamente.
Sistemas Distribuídos
28
Java RMI
Passagem de Parâmetros
• Objetos podem ser passados como
parâmetros, utilizando passagem por valor
– Basta que implementem a interface
Serializable
• Carregamento Dinâmico de Código:
– Se o código da classe de um objeto não
estiver disponível na JVM para onde o objeto
foi enviado, o mesmo é carregado
dinamicamente.
Sistemas Distribuídos
29
Exemplo de Passagem
de Objeto como Parâmetro
• Interface Remota:
interface Compute extends Remote {
Object executeTask (Task t) throws
RemoteException; .....
}
• Interface do Objeto Passado como
Parâmetro:
interface Task extends Serializable {
Object execute ();
}
Sistemas Distribuídos
30
Exemplo de Passagem
de Objeto como Parâmetro
• Servidor:
class computeEngine
extends UnicastRemoteObject
implements Compute { ....
public Object executeTask (Task t)
{ return t.execute(); }
public static void main (String[] args)
{ // Cria e registra objeto remoto }
.....
}
Sistemas Distribuídos
31
Exemplo de Passagem
de Objeto como Parâmetro
• Cliente:
class Pi implements Task { .....
public Object execute()
{ ...... } ......
// Calcula valor de 
public static void main (String[] args) { ......
Compute comp= “referência p/ objeto remoto”
Pi task= new Pi();
Float x= (Float) comp.executeTask (task);
}
}
Sistemas Distribuídos
32
Java RMI
Considerações Finais
• Vantagens:
– Portável entre plataformas para as quais
existe uma implementação de Java
– Mobilidade de Objetos (e do código
associado)
• Desvantagens:
– Solução proprietária da linguagem Java
Sistemas Distribuídos
33