Agentes Moveis - Aspectos De  Desenvolvimento
Upcoming SlideShare
Loading in...5
×
 

Agentes Moveis - Aspectos De Desenvolvimento

on

  • 2,872 views

Seminário apresentado na disciplina de Computação Móvel.

Seminário apresentado na disciplina de Computação Móvel.
Introdução a Agentes Móveis, Aglets, Exemplos.

Statistics

Views

Total Views
2,872
Views on SlideShare
2,854
Embed Views
18

Actions

Likes
0
Downloads
70
Comments
0

3 Embeds 18

http://www.luizmatos.eti.br 16
http://s3.amazonaws.com 1
http://www.slideshare.net 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Agentes Moveis - Aspectos De  Desenvolvimento Agentes Moveis - Aspectos De Desenvolvimento Presentation Transcript

  • Agentes Móveis Aspectos de Desenvolvimento Componentes : Luiz Matos, Marcelo Almeida, Margarete Sá Salvador, 2007 Universidade Federal da Bahia Especialização em Sistemas Distribuídos Computação Móvel
  • Organização do estudo
    • Introdução a Agentes Móveis
      • Princípios básicos
      • Quando usar
      • Porque usar
      • Aspectos de segurança
    • Desenvolvimento de Agentes Móveis
      • Agentes Móveis baseados em Java
      • Frameworks e Aplicações existentes
      • Aglets: uma visão geral
      • Demonstração: Desenvolvendo um agente móvel com Aglets
    • Considerações Finais
    • Referências
    • Introdução a Agentes Móveis
      • Princípios básicos
      • Quando usar
      • Porque usar
      • Aspectos de segurança
  • Princípios básicos
    • Crescimento das redes de informação;
    • Desenvolvimento de aplicações distribuídas;
    • Remote Procedure Calling (RPC);
    • Remote Method Invocation (RMI);
    Figura 1. Funcionamento RPC (WHITE, 1996)
    • Permite que um computador chame procedimentos em outro.
    • Uma requisição inclui os argumentos do procedimento.
    • A resposta inclui os resultados.
    • Cada interação entre cliente e servidor consiste de duas conexões;
    • A comunicação deve ser contínua.
    Contextualização
  • Princípios básicos
    • A alternativa é permitir que um computador além de chamar procedimentos em outro, forneça os procedimentos a serem executados.
    Figura 2. Funcionamento Agentes Móveis (WHITE, 1996)
    • A interação não requer uma comunicação contínua;
    • Um agente do cliente visita o servidor;
    • O agente possui procedimentos e argumentos;
    • O servidor o executa local-mente, podendo enviar seu próprio agente para outro computador.
    Contextualização
    • É um programa em execução que passa de um computador para outro , realizando uma tarefa em nome de alguém e finalmente retornando com os resultados obtidos a esse alguém. (COULOURIS e outros, 2007)
    • São programas de computador auto-contidos e identificáveis que podem se mover dentro da rede e agir em nome do usuário ou de uma outra entidade. (PHAM e KARMOUCH, 1998)
    Princípios básicos Definição Agente Interações Locais Cliente Interações de Rede Figura 3. Representação Agentes Móveis
      • Carrega consigo:
        • – seu código;
        • – informação de estado de execução;
        • – estado dos dados;
    Servidor
    • Ag ência : É o ambiente de execução dos agentes, dando suporte ao seu ciclo de vida – recebe, executa, envia, controla recursos, etc.
    • Places : Ambiente de execução específico de uma agência, que disponibiliza um conjunto de serviços (recursos). Uma agência pode ter vários places, dando um contexto ao agente.
    • Agents : Consiste de Código + Estado, tem atributos como identidade, localização, autoridade e permissões.
    • Travel : É a transferência de um agente de um lugar para outro, que só ocorre se o agente está autorizado a visitar o destino.
    Princípios básicos Conceitos Figura 5. Representação Places (WHITE, 1996) Figura 6. Representação Agents (WHITE, 1996) Figura 7. Representação Travel (WHITE, 1996) Agente Serviços/Recursos Figura 4. Representação Agência
  • Migração de Código
    • Modelos
      • Mobilidade fraca – Quando ocorre a transferência de código e dados para a Agência destino.
      • Mobilidade forte – O agente (código, dados e estado de execução) é transportado para a Agência destino. Assim, a sua execução continua a partir da instrução seguinte àquela que causou a migração.
    • Razões para o uso
      • Melhora no Desempenho
        • permitir a distribuição de tarefas a vários computadores eliminando o processamento centralizado.
      • Flexibilidade
        • a divisão da aplicação em diferentes partes (por arquitetura de multicamadas).
    Princípios básicos
  • Quando usar
    • Gerência de redes – monitoramento, filtragem e notificação;
    • Processamento paralelo – particionamento e alocação dinâmica de tarefas;
    • Comércio eletrônico – negociação, transação e busca;
    • Entretenimento – busca de informações, jogos em ambientes virtuais distribuídos, Etc..
    • Redu zir custos de comunicação; Ganhar performance através da delegação de tarefas; Reduzir a carga de rede e superar a latência de comunicação; Descentralização do Processamento, Etc..
    Porque usar
    • Dados armazenados nos computadores;
    • Dados armazenados no agente;
    • A integridade do agente;
    • A não interrupção indevida do agente;
    • A não personificação indevida do agente;
    • A não utilização indevida de recursos computacionais.
    O que devemos proteger*? Aspectos de segurança
    • Compilar o código localmente;
    • Verificar executáveis em ambientes controlados;
    • Autenticação de usuários;
    • Criar políticas de acesso a recursos;
    • Criptografia e assinatura de mensagens.
    Como podemos proteger*? * Adaptado de Cunha (2005).
  • Representação das ameaças Sistema de Agentes M óveis Entidades Externas Aspectos de segurança 1. ameaças do servidor contra o agente; 2. ameaças do agente contra o servidor; 3. ameaças do agente contra outro agente sendo executado no mesmo servidor; 4. outras ameaças contra o sistema de agentes. Personificação, negação de serviço, alteração de dados ou código, acesso não autorizado, entre outros. Figura 8. Ameaças em Agentes Móveis (UTO, 2003)
    • Desenvolvimento de Agentes Móveis
      • Agentes Móveis baseados em Java
      • Frameworks e Aplicações existentes
      • Aglets: uma visão geral
      • Demonstração: Desenvolvendo um agente móvel com Aglets
  • Agentes móveis baseados em Java
    • A escolha da linguagem Java para o desenvolvimento de Agentes Móveis está fortemente relacionada às suas características de:
      • Portabilidade;
      • Suporte a requisitos de rede;
      • Mecanismos de serialização;
      • etc
    • Em Java :
    • Aglets - IBM, Japão
    • Odyssey - General Magic, EUA
    • Voyager - ObjectSpace, EUA
    • Em outras linguagens :
    • Telescript - General Magic, EUA
    • D’Agents - Dartmouth College, Inglaterra
    • TACOMA - Universidade de Cornell, EUA
    Frameworks e Aplicações existentes
  • Conceitos básicos
    • Plataforma de agentes móveis baseados na linguagem de programação Java;
    • Lançada em 1996, resultado de trabalhos desenvolvidos nos laboratórios da IBM do Japão;
    • Utilizam contexto- aglet (espaço de trabalho dos Aglets) onde os agentes são gerenciados;
    • Código aberto disponibilizado pela IBM em licença pública;
    • Aglet = AGent + appLET.
    Aglets: uma visão geral
      • Aglet :
        • Autônomo por possuir sua própria thread de execução;
        • Objeto Java com capacidade de se deslocar por nodos da web;
        • Reativo pela capacidade de responder mensagens.
      • Proxy :
        • Representante local do Aglet;
        • Usado para proteger o acesso aos métodos públicos deste;
        • Provê transparência de localização (é um objeto estático enquanto que um Aglet é móvel).
    Conceitos básicos Aglets: uma visão geral
      • Contexto :
        • É o habitat do Aglet (agência), onde o mesmo não só vive como obtém informações sobre seu ambiente atual.
        • É um objeto estacionário que monitora os Aglets e mantém o ambiente seguro contra invasões.
      • Mensagem :
        • Objeto passado entre Aglets de forma síncrona ou assíncrona, usado para a colaboração entre eles.
      • Itinerário :
        • É o caminho que o Aglet tem que percorrer.
      • Identificador :
        • Identidade única do Aglet usado em toda a sua vida.
    Conceitos básicos Aglets: uma visão geral
    • O ato de mover/migrar um Aglet de um contexto para o outro é feito de forma ativa ou passiva.
      • Migração ativa : O próprio Aglet decide migrar o estado corrente de sua execução para um novo contexto através da operação dispatch ;
      • Migração passiva : O contexto (agência) invoca o método retract para requisitar que o agente volte ao seu local de origem;
      • A migração de um Aglet é feita por mobilidade fraca utilizando serialização de classes.
    Mobilidade Aglets: uma visão geral
  • Ciclo de Vida Aglets: uma visão geral Figura 9. Ciclo de Vida de um Aglet (JUNG, [s.d.]) O Aglet toma seu lugar em um contexto, ganha seu identificador e é inicializado. Um aglet nasce igual o pai exceto ID e estado. Ação de despachar um Aglet de um contexto e inseri-lo em outro, onde este reiniciará sua execução. Um Aglet, previamente despachado, é trazido de volta a um contexto e seu estado volta junto. Um Aglet é retirado temporariamente de seu contexto e é colocado em um contexto secundário. Um Aglet desativado pode ser reativado, voltando a executar a partir do seu estado no momento da esativação. O Aglet é retirado de seu contexto e morre. Seu estado é perdido para sempre.
      • Modelo de programação baseado em eventos de callback manipulados através de tratadores denominados listeners ;
      • Eventos atuam durante as várias fases do ciclo de vida do Aglet;
      • Programador utiliza tais eventos para ligar ações aos Aglets;
      • Listeners podem ser combinados para executar tarefas complexas;
      • Há três tipos de listeners :
        • CloneListener:
        • MobilityListener:
        • PersistenceListener:
    Modelo de Eventos Aglets: uma visão geral
      • CloneListener:
        • Gerencia os eventos associados à clonagem.
        • Métodos utilizados:
          • onCloning (logo antes da clonagem);
          • onClone (durante a clonagem);
          • onCloned (depois da clonagem).
    Tipos de Listeners Aglets: uma visão geral
      • MobilityListener:
        • Gerencia os eventos associados à mobilidade.
        • Métodos utilizados:
          • onDispatching (logo antes do despacho);
          • onReverting (logo antes da retratação);
          • onArrival (assim que o Aglet chega ao destino).
    Tipos de Listeners Aglets: uma visão geral
      • PersistenceListener:
        • Gerencia os eventos associados à persistência do Aglet no contexto.
        • Métodos utilizados:
          • onDeactivating (logo antes da desativação);
          • onActivation (logo depois da ativação);
      • Outros métodos utilizados:
        • onCreation e onArrival (métodos automaticamente acionados quando um Aglet chega ao contexto destino).
    Tipos de Listeners Aglets: uma visão geral
      • Baseado no paradigma de pedido/resposta (request/reply) entre máquinas.
      • Operações suportados pelo protocolo:
    ATP – Agent Transfer Protocol Aglets: uma visão geral Figura 10. Operações do ATP (JUNG, [ s.d.]) solicita a um sistema de agentes destino que reconstrua um agente a partir do conteúdo de uma requisição e inicie sua execução. solicita a um sistema de agentes destino que envie de volta um determinado agente ao emissor. solicita a um receptor que este recupere e envie alguma informação. Similar ao método GET do HTTP. usado para transmitir uma mensagem a um agente identificado por um agent-id e retornar alguma resposta à ação.
      • Aglets não invocam métodos de outros diretamente;
      • Utilizam objetos AgletProxy , que agem como representantes do agente;
      • A classe AgletProxy utiliza métodos como dispatch(), clone(), deactivate() e dispose() .
    Interações entre Aglets Aglets: uma visão geral Figura 11. Relação entre Aglet e proxy (JUNG, [s.d.])
  • Aglet Server (TAHITI) Figura 12. Interface TAHITI Demonstração: Desenvolvendo um agente móvel com Aglets Cria um novo Aglet. Exibe caixa de dialogo de um Aglet. Traz informações sobre o Aglet selecionado. Elimina um Aglet Clona um Aglet Envia um Aglet para um host destino Traz de volta um Aglet enviado a outro host Aglet em atividade. - Demonstração da ferramenta
    • import com.ibm.aglet.*;
    • public class FirstAglet extends Aglet {
      • //Metodo run, executado no dispatching
      • public void run () {
      • String hello = “oi pessoal”;
        • System. out .println(hello + "! ");
        • for(int i=0; i<3; i++) {
        • System. out .println(i);
      • }
      • System. out .println(&quot;Eu falei: &quot; + hello.toUpperCase());
      • }
    • }; //Fim da classe FirstAglet
    Exemplo 1 – Hello World Móvel Demonstração: Desenvolvendo um agente móvel com Aglets Importar pacotes da API Herdar a classe Aglet Implementar método run()
  • Exemplo 2 – Tratando Listeners Demonstração: Desenvolvendo um agente móvel com Aglets
    • import com.ibm.aglet.*;
    • import com.ibm.aglet.event.*;
    • public class MyListener implements
    • MobilityListener, CloneListener, PersistencyListener {
      • /**
      • * Metodos da interface MobilityListener
      • */
      • public void onArrival (MobilityEvent event) {
      • System. out .println(&quot;O Agente chegou: &quot; + event);
      • }
      • public void onDispatching (MobilityEvent event) {
      • System. out .println(&quot;Antes de mover: &quot; + event);
      • }
      • public void onReverting (MobilityEvent event) {
      • System. out .println(&quot;Antes de voltar para meu lugar: &quot; + event);
      • }
      • //Continua no próximo slide..
    Importar pacotes da API Implementar Interfaces Implementar métodos
      • /*
      • * Metodos da interface CloneListener
      • */
      • public void onClone (CloneEvent event) {
      • System. out .println(&quot;Eu sou o clone: &quot; + event);
      • }
      • public void onCloned (CloneEvent event) {
      • System. out .println(&quot;Um clone de mim foi criado: &quot; + event);
      • }
      • public void onCloning (CloneEvent event) {
      • System. out .println(&quot;Alguem esta me clonando: &quot; + event);
      • }
      • /*
      • * Metodos da interface PersistencyListener
      • */
      • public void onActivation (PersistencyEvent event) {
      • System. out .println(&quot;Ativando: &quot; + event);
      • }
      • public void onDeactivating (PersistencyEvent event) {
      • System. out .println(&quot;Desativando: &quot; + event);
      • }
    • }; //Fim da classe MyListener
    Demonstração: Desenvolvendo um agente móvel com Aglets Implementar métodos Implementar métodos
  • Exemplo 2 – Tratando Listeners import com.ibm.aglet.*; import com.ibm.aglet.event.*; public class MyListenerTest extends Aglet { public boolean move = true; public void onCreation (Object init) { //cria um objeto listener MyListener listener = new MyListener(); //registra um listener mobility this.addMobilityListener((MobilityListener)listener); //registra um listener clone this.addCloneListener((CloneListener)listener); //registra um listener persistency this.addPersistencyListener((PersistencyListener)listener); } public void run () { System.out.println(&quot;Ola pessoal!&quot;); } }; //Fim da classe (Aglet) MyListenerTest Demonstração: Desenvolvendo um agente móvel com Aglets Importar pacotes da API Herdar a classe Aglet
  • Exemplo 3 – Tratando Proxys Demonstração: Desenvolvendo um agente móvel com Aglets
    • import com.ibm.aglet.*;
    • public class ProxyInfoChild extends Aglet {
      • public void run () {
      • print(&quot;Rodando...&quot;);
      • }
      • private void print(String s) {
      • System. out .println(ProxyInfoExample. NAME + &quot; (child): &quot; + s);
      • }
    • }; //Fim da classe (Aglet) ProxyInfoChild
    Importar pacotes da API Herdar a classe Aglet
  • import com.ibm.aglet.*; import java.util.Enumeration; import java.util.Date; public class ProxyInfoExample extends Aglet { public void run () { print(&quot;STARTING --------------------&quot;); try { print(“Criando o child...&quot;); AgletProxy proxy = getAgletContext().createAglet(getCodeBase(), &quot;examples.ProxyInfoChild&quot;, null); print(“Finalizando a criacao do child.&quot;); pause(); print(“Usando o proxy diretamente: &quot;); print(&quot;Identificador: '&quot; + proxy. getAgletID () + &quot;'&quot;); print(&quot;Code Base: '&quot; + &quot;(Depreciated, using aglet.getCodeBase()) &quot; + getCodeBase () + &quot;'&quot;); print(“Nome da Classe: '&quot; + proxy. getAgletClassName () + &quot;'&quot;); pause(); print(&quot;... E agora, as informacoes do objeto: &quot;); AgletInfo info = proxy.getAgletInfo(); print(&quot;Identificador: '&quot; + info. getAgletID () + &quot;'&quot;); print(&quot;Code Base: '&quot; + info. getCodeBase () + &quot;'&quot;); print(“Nome da Classe: '&quot; + info. getAgletClassName () + &quot;'&quot;); print(&quot;Origem: '&quot; + info. getOrigin () + &quot;'&quot;); print(“Endereco: '&quot; + info. getAddress () + &quot;'&quot;); print(“Hora de Criacao: '&quot; + new Date(info. getCreationTime ()) + &quot;'&quot;); } //Continua no proximo slide.. Importar pacotes da API Herdar a classe Aglet Demonstração: Desenvolvendo um agente móvel com Aglets
  • Exemplo 3 – Tratando Proxys
      • catch (Exception e) {
      • print(“Falha ao criar o child.&quot;);
      • print(e.getMessage());
      • }
      • }; //Fim do metodo run()
      • static public String NAME = &quot;ProxyInfoExample&quot;;
      • private void print(String s) {
      • System.out.println(NAME + &quot; (parent): &quot; + s);
      • }
      • private static long SLEEP = 3000;
      • private void pause() {
        • try {
        • Thread.sleep(SLEEP);
        • } catch (InterruptedException ie) { }
    • } //Fim do metodo pause
    • }//Fim da classe ProxyInfoExample
  • Considerações finais
    • Dificuldades: escassez de conteúdo atualizado e carência na disponibilidade de aplicações.
    • Agentes Móveis possui uma rápida curva de aprendizado para o desenvolvedor Java.
    • Provê soluções pontuais, para problemas específicos.
    • Sobreposição por tecnologias ‘da moda’.
    Conclusões do Grupo Desafios na área
      • Capacidade de controle de agentes;
      • Segurança;
      • Tolerância a falhas;
      • Padr ões de Projeto;
      • Novas aplicabilidades.
  • Referências
    • AGLETS. The IBM Aglets Software Development Kit Version 2.02. Disponível em: <http://www.trl.ibm.com/aglets/>. Acesso em: 04 set. 2007.
    • BELLONI, Edgardo A. A Multi-paradigm Approach for Mobile Agents Development. Disponível em : <http://journal.info.unlp.edu.ar/
    • Journal/journal4/papers/pap1.pdf>. Acesso em: 06 set. 2007.
    • CHESS, David; HARRISON, Colin; KERSHENBAUM, Aaron. Mobile Agents: are they a good idea? IBM Research Report, 1995. Disponível em: <http://citeseer.ist.psu.edu/chess95mobile.html>. Acesso em: 15 ago. 2007.
    • COULOURIS, George; DOLLIMORE, Jean; KINDBERG, Tim. Sistemas distribuídos: conceitos e projeto . 4. ed. Bookman, 2007.
    • CUNHA, Leonardo Godinho. Segurança em Códigos Móveis. Julho, 2005. Disponível em : <http://www-di.inf.puc-rio.br/~endler/semGSD/monografias/leonardo-godinho.pdf>. Acesso em: 02 set. 2007.
    • FERRARI, Luca. The Aglets 2.0.2 User’s Manual. Outubro, 2004. Disponível em: <http: //aglets.sourceforge.net/>. Acesso em: 05 set. 2007.
    • FUGGETTA, Alfonso; PICCO, Gian Pietro; VIGNA, Giovanni Vigna. Understanding Code Mobility. IEEE Transactions on Software Engineering, Volume 24, No. 5, p. 342-361, Maio 1998.
    • JUNG, Galeno. Manual de Utilização do Aglets. Universidade Federal de Santa Catarina, Inteligência Artificial Aplicada à Controle e Automação. Apostila de aula, [s.d.]
    • LIMA, Emerson Ferreira de Araújo. Formalização e Análise de Padrões de Projeto para Agentes Móveis. Dissertação de Mestrado. Universidade Federal de Campina Grande, Coordenação de Pós-Graduação em Informática, Fevereiro de 2004. Disponível em: <http://copin.ufcg.edu.br/twiki-public/pub/COPIN/Dissertacoes
    • Mestrado/DissertacaoEmersonFerreiraALima.pdf>. Acesso em: 06 set. 2007.
    • MAHMOUD, Qusay. Mobile Agents and Java: java is the ideal language for writing mobile agents . Disponível em: <http://www2.sys-con.com/itsg/virtualcd/Java/archives/0211/mahmoud/index.html>. Acesso em: 06 set. 2007.
  • MALUTA, Líliam C. Gaiotto. Aplicação em Computação Móvel para Monitoramento de Pacientes em UTI. Disponível em: <http://www.wirelessbrasil.org/wirelessbr/colaboradores/liliam_maluta/monitor_uti_01. html>. Acesso em: 05 set. 2007. MENDES, Manuel de Jesus; SILVA, Flávio M. de Assis. Mobile Agents in Autonomous Decentralized Systems. IEEE Autonomous Decentralized Systems, 1999. Integration of Heterogeneous Systems. Proceedings. MODAK, Vishal D.; LANGAN, David D.; HAIN, Thomas F. A Pattern-based Development Tool for Mobile Agents. ACM SIGCSE Bulletin, Volume 37, p. 72-75, Fev. 2005. OBJECT Management Group. Agent Technology Green Paper. Agent Platform Special Interest Group, 2000. Disponível em: <http://www.objs.com/agent/agents_Green_Paper_v100.doc>. Acesso em: 06 set. 2007. OYAMADA, Márcio Seiji; ITO, Sérgio Akira. Aglets: agentes móveis em java. Disponível em: <http://www.inf.ufrgs.br/ procpar/disc/cmp134/trabs/T2/981/Aglets/aglets.html>. Acesso em: 05 set. 2007. PHAM, Vu Anh; KARMOUCH, Ahmed. Mobile Software Agents: an overview. IEEE, 1998. Disponível em: <http://www.comsoc.org/ci/private/1998/jul/Karmouch.html>. Acesso em: 05 set. 2007. UTO, Nelson. Segurança de Sistemas de Agentes Móveis. Dissertação de Mestrado. Universidade Estadual de Campinas, Instituto de Computação, Abril de 2003. Disponível em: <http://www.las.ic.unicamp.br/paulo/teses/trabalhos-relacionados/NelsonUto.pdf>. Acesso: 06 set. 2007. Wayne A. Jansen. Countermeasures for Mobile Agent Security. Special Issue on Advanced Security Techniques for Network Protection, Elsevier Science BV, novembro de 2000. In: UTO, Nelson. Segurança de Sistemas de Agentes Móveis. Dissertação de Mestrado. Universidade Estadual de Campinas, Instituto de Computação, Abril de 2003. Disponível em: <http://www.las.ic.unicamp.br/paulo/teses/trabalhos- relacionados/NelsonUto.pdf>. Acesso em: 06 set. 2007. WHITE, Jim. Mobile Agents White Paper. General Magic, 1996. Disponível em: <http://citeseer.ist.psu.edu/white96mobile.html>. Acesso em: 15 ago. 2007. WONG, David; PACIOREK, Noemi; MOORE, Dana. Java-based Mobile Agents. Communications Of The Acm, v. 42, n. 3, p. 92-102, mar. 1999. Referências
  • Figura 5. Representação Places (WHITE, 1996) Figura 6. Representação Agents (WHITE, 1996) Figura 7. Representação Travel (WHITE, 1996)
  •