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

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Agentes Moveis - Aspectos De Desenvolvimento

1,771
views

Published on

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.

Published in: Technology

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
1,771
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
70
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide
  • Transcript

    • 1. 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
    • 2. 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
    • 3.
      • Introdução a Agentes Móveis
        • Princípios básicos
        • Quando usar
        • Porque usar
        • Aspectos de segurança
    • 4. 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
    • 5. 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
    • 6.
      • É 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
    • 7.
      • 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
    • 8. 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
    • 9. 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
    • 10.
      • 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).
    • 11. 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)
    • 12.
      • 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
    • 13. 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
    • 14.
      • 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
    • 15. 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
    • 16.
        • 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
    • 17.
        • 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
    • 18.
      • 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
    • 19. 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.
    • 20.
        • 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
    • 21.
        • 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
    • 22.
        • 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
    • 23.
        • 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
    • 24.
        • 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.
    • 25.
        • 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.])
    • 26. 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
    • 27.
      • 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()
    • 28. 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
    • 29.
        • /*
        • * 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
    • 30. 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
    • 31. 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
    • 32. 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
    • 33. 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
    • 34. 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.
    • 35. 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.
    • 36. 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
    • 37. Figura 5. Representação Places (WHITE, 1996) Figura 6. Representação Agents (WHITE, 1996) Figura 7. Representação Travel (WHITE, 1996)
    • 38.  

    ×