Objetivos e Metodologia

• Compreender os fundamentos, técnicas e desafios dos sistemas distribuídos (Tanenbaum, Coulouris).
• Explorar comunicação, coordenação e aplicações práticas (Silberschatz).
• Relacionar com pré-requisitos e tecnologias atuais (ex.: Kubernetes, Kafka).

Ementa e Avaliação

• 60 horas distribuídas em 15 semanas (4h/semana).
• Bibliografia Obrigatória:
  • Coulouris, G., Dollimore, J., Kindberg, T., & Blair, G. (2011). Distributed Systems: Concepts and Design (5th ed.). Addison-Wesley. (Livro-texto essencial, abrange conceitos fundamentais e estudos de caso.)
  • Tanenbaum, A. S., & Van Steen, M. (2016). Distributed Systems: Principles and Paradigms (3rd ed.). Pearson. (Outra excelente opção, focado nos princípios e paradigmas de projeto.)
  • Lynch, N. A. (1996). Distributed Algorithms. Morgan Kaufmann. (Foco em algoritmos distribuídos, mais aprofundado.)
  • Attiya, H., & Welch, J. (2004). Distributed Computing: Fundamentals, Simulations and Advanced Topics (2nd ed.). Wiley. (Aborda fundamentos teóricos e tópicos avançados.)
• Bibliografia Complementar:
  • Burns, B., Grant, B., Oppenheimer, D., Brewer, E., & Wilkes, J. (2019). Site Reliability Engineering: How Google Runs Production Systems. O'Reilly Media. (Visão prática sobre operação de sistemas distribuídos em larga escala.)
  • Kleppmann, M. (2017). Designing Data-Intensive Applications. O'Reilly Media. (Focado em aplicações distribuídas que lidam com grandes volumes de dados.)
  • Newman, S. (2021). Building Microservices: Designing Fine-Grained Systems (2nd ed.). O'Reilly Media. (Arquitetura de microsserviços como um estilo de sistemas distribuídos.)
  • Artigos clássicos:
    • "Time, Clocks, and the Ordering of Events in a Distributed System" (Lamport, 1978).
    • "The Byzantine Generals Problem" (Lamport, Shostak, & Pease, 1982).
    • "Paxos Made Simple" (Lamport, 2001).

Tecnologias Atuais

• Linguagens de Programação: Go, Java, Python, C++, Rust.
• Mensageria: Apache Kafka, RabbitMQ, NATS, Redis Pub/Sub.
• Containers e Orquestração: Docker, Kubernetes.
• Computação em Nuvem: AWS, Azure, Google Cloud Platform (GCP).
• Bancos de Dados Distribuídos: Cassandra, MongoDB, CockroachDB, etcd.
• APIs RESTful e gRPC: para comunicação entre serviços.
• Ferramentas de Monitoramento e Observabilidade: Prometheus, Grafana, Jaeger, OpenTelemetry.
• Serverless: AWS Lambda, Azure Functions, Google Cloud Functions.

Atividades

• Seminários temáticos (ex.: DNS, Blockchain).
• Práticas laboratoriais (ex.: RPC com gRPC, simulação de falhas).
• Projeto final integrador: Implementação de um SD simples.

Nesta unidade, serão apresentados os conceitos iniciais, a evolução histórica e a relevância dos sistemas distribuídos (SD) na computação moderna, com base em Tanenbaum, Coulouris e Silberschatz. Exploraremos definições, características fundamentais e exemplos práticos que ilustram sua aplicação no mundo real.

Definições de Sistemas Distribuídos

• Andrew Tanenbaum: "Uma coleção de computadores independentes que se apresenta ao usuário como um sistema único e consistente" (Tanenbaum & Van Steen, Cap. 1). Enfatiza a transparência e a integração percebida pelo usuário.
• George Coulouris: "Sistema Distribuído é uma coleção de computadores autônomos interligados através de uma rede de computadores e equipados com software que permita o compartilhamento dos recursos do sistema: hardware, software e dados" (Coulouris et al., Cap. 1). Destaca a autonomia e o compartilhamento.
• Abraham Silberschatz: "Um sistema que coordena processos em máquinas distintas por meio de comunicação baseada em mensagens" (Silberschatz et al., Cap. SD). Foca na coordenação e na comunicação entre nós.
• Leslie Lamport (curiosidade): “Você sabe que existe um sistema distribuído quando a falha de um computador que você nunca ouviu falar impede que você faça qualquer trabalho” [Assista ao vídeo]. Ilustra a dependência invisível em SD.

Fundamentos e Características

• Transparência: Oculta a complexidade da distribuição (ex.: localização, acesso, falha – Tanenbaum Cap. 1). Exemplo: o usuário acessa um arquivo remoto como se fosse local.
• Escalabilidade: Capacidade de crescer horizontalmente adicionando nós (Coulouris Cap. 1). Exemplo: servidores web escaláveis como o Google.
• Tolerância a Falhas: Continuidade do serviço mesmo com falhas parciais (Tanenbaum Cap. 7). Exemplo: replicação em bancos de dados distribuídos.
• Concorrência: Gerenciamento de múltiplos processos simultâneos (Silberschatz). Exemplo: exclusão mútua distribuída.
• Comunicação e Coordenação: Baseadas em mensagens ou chamadas remotas (RPC, RMI – Coulouris Cap. 4). Essenciais para sincronização entre processos.

Evolução Histórica

• Mainframes (década de 1960): Computação centralizada com alto custo e baixa acessibilidade (Silberschatz).
• Clusters e Redes (década de 1980): Surgimento de sistemas paralelos e distribuídos para maior desempenho (Tanenbaum Cap. 1).
• Internet (década de 1990): Expansão dos SD com a conectividade global, popularizando modelos como cliente-servidor (Coulouris Cap. 2).
• Computação em Nuvem (2000+): SD escaláveis e sob demanda (ex.: AWS, Google Cloud).
• Computação Móvel e IoT (2010+): Integração de dispositivos heterogêneos em redes ubíquas.

Exemplos Práticos

• Bancos e Agências: Sistemas de transações distribuídas (ex.: SWIFT) garantem consistência e disponibilidade em tempo real.
• Internet: Rede global de servidores interconectados (ex.: DNS resolve nomes de domínio de forma distribuída).
• Computação em Nuvem: Plataformas como AWS e Azure utilizam SD para oferecer serviços escaláveis.
• Sistemas de Arquivos Distribuídos: Ex.: Google File System (GFS) e Hadoop HDFS para armazenamento massivo.
• Redes P2P: Compartilhamento de recursos sem servidor central (ex.: BitTorrent, Napster).
• Supercomputadores: Clusters distribuídos no Top 500 (ex.: Summit) para simulações científicas.
• IoT e Computação Ubíqua: Sensores e dispositivos móveis integrados (ex.: smart homes).

Desafios Atuais

• Latência e Largura de Banda: Impacto da comunicação em redes amplas (Coulouris Cap. 3).
• Segurança: Proteção contra ataques distribuídos (ex.: DDoS – Tanenbaum Cap. 8).
• Consistência: Balanceamento entre disponibilidade e consistência (Teorema CAP – Coulouris Cap. 7).

Este slide explora a evolução dos sistemas computacionais e o modelo cliente/servidor, destacando como as características fundamentais dos sistemas distribuídos (SD) moldaram seu desenvolvimento, com base em Tanenbaum, Coulouris e Silberschatz.

Características Fundamentais de Sistemas Distribuídos

• Múltiplos Nós Separados: Cada nó é fisicamente independente, com seu próprio SO, CPU e memória (Tanenbaum Cap. 1).
• Comunicação via Rede: Nós interagem por mensagens ou protocolos de rede (ex.: TCP/IP, RPC – Coulouris Cap. 4).
• Cooperação Externa: Nós autônomos colaboram para um objetivo comum, como processar uma tarefa distribuída (Silberschatz).
• Distribuição de Falhas: O sistema continua funcionando mesmo com falhas parciais, graças à redundância e tolerância (Tanenbaum Cap. 7).

Evolução dos Sistemas Computacionais

• Origem e Motivação:
  • Busca por alto desempenho, baixo custo e maior disponibilidade (Tanenbaum Cap. 1).
  • Necessidade de processamento paralelo e compartilhamento de recursos em larga escala.
• Evolução Histórica:
  • Mainframes (1960-1970): Computação centralizada, cara e limitada a grandes organizações (Silberschatz).
  • Clusters (1980-1990): Grupos de máquinas colaborando para tarefas complexas, como simulações científicas.
  • Sistemas Distribuídos Modernos (2000+): Exemplos como Google File System (GFS) e Hadoop HDFS para armazenamento e processamento massivo (Coulouris Cap. 2).
  • Computação em Nuvem (2010+): Virtualização e escalabilidade sob demanda (ex.: AWS EC2, Google Compute Engine).

Evolução do Modelo Cliente/Servidor

• Transição para Arquiteturas Distribuídas:
  • De mainframes centralizados para sistemas com múltiplos servidores e clientes (Coulouris Cap. 2).
  • Impacto das redes e SOs modernos: comunicação baseada em mensagens e coordenação entre nós (Silberschatz).
• Características do Modelo Cliente/Servidor em SD:
  • Múltiplos Nós: Clientes e servidores operam em máquinas distintas, colaborando via rede.
  • Comunicação via Rede: Uso de protocolos como HTTP, gRPC e WebSocket para interações cliente-servidor (Coulouris Cap. 4).
  • Cooperação Externa: Clientes solicitam serviços, enquanto servidores processam e respondem autonomamente.
  • Tolerância a Falhas: Redundância (ex.: servidores espelhados) e replicação garantem continuidade (Tanenbaum Cap. 7).
  • Escalabilidade: Adição de servidores para suportar mais clientes, como em arquiteturas de load balancing.
• Exemplos Práticos:
  • Web (HTTP): Navegadores (clientes) acessam servidores web para renderizar páginas (ex.: Apache, Nginx).
  • Bancos de Dados Distribuídos: Sistemas como Cassandra e CockroachDB replicam dados entre nós.
  • Streaming de Vídeo: Netflix e YouTube usam CDNs (Content Delivery Networks) para distribuir conteúdo.
  • Aplicativos Móveis: Apps como WhatsApp interagem com servidores na nuvem para sincronização.
  • DNS: Resolução distribuída de nomes de domínio entre servidores hierárquicos.

Impacto das Tecnologias Modernas

• Computação em Nuvem: AWS, Azure e GCP expandiram o modelo cliente/servidor com serviços escaláveis e virtualizados.
• Microsserviços: Divisão de aplicações em serviços independentes (ex.: Netflix usa centenas de microsserviços via APIs).
• Serverless: Abstração da infraestrutura (ex.: AWS Lambda), onde clientes invocam funções sem gerenciar servidores.
• Edge Computing: Processamento próximo ao cliente (ex.: IoT e 5G) para reduzir latência.

Desafios no Modelo Cliente/Servidor

• Latência de Rede: Comunicação entre cliente e servidor pode ser um gargalo (Coulouris Cap. 3).
• Consistência: Garantir dados consistentes em servidores replicados (ex.: Teorema CAP – Coulouris Cap. 7).
• Segurança: Proteger comunicação entre nós contra ataques (Tanenbaum Cap. 8).

Este slide apresenta as definições essenciais e os conceitos fundamentais dos sistemas distribuídos (SD), com base em Tanenbaum, Coulouris e Silberschatz, destacando como eles formam a base teórica e prática da área.

Definições de Sistemas Distribuídos

• Andrew Tanenbaum: "Uma coleção de computadores independentes que se apresenta ao usuário como um sistema único e consistente" (Tanenbaum & Van Steen, Cap. 1).
  • Foco na transparência e na ilusão de um sistema coeso, apesar da distribuição física.
  • Exemplo: Um sistema de arquivos distribuído (NFS) parece local ao usuário.
• George Coulouris: "Uma coleção de computadores autônomos interligados através de uma rede de computadores e equipados com software que permita o compartilhamento dos recursos do sistema: hardware, software e dados" (Coulouris et al., Cap. 1).
  • Ênfase na autonomia dos nós e no compartilhamento eficiente de recursos.
  • Exemplo: O DNS compartilha informações de resolução de nomes entre servidores.
• Abraham Silberschatz: "Sistema que coordena processos em máquinas distintas via mensagens" (Silberschatz et al., Cap. SD).
  • Destaque para a comunicação e coordenação como pilares dos SD.
  • Exemplo: Filas de mensagens (Kafka) coordenam processos em arquiteturas distribuídas.
• Leslie Lamport (curiosidade): “Você sabe que existe um sistema distribuído quando a falha de um computador que você nunca ouviu falar impede que você faça qualquer trabalho.”
  • Ilustra a interdependência e a complexidade inerentes aos SD.
  • Exemplo: Uma falha em um servidor de CDN impede o carregamento de um vídeo no YouTube.
  • [Assista ao vídeo]

Conceitos-Chave

• Transparência: Oculta a complexidade da distribuição para o usuário (Tanenbaum Cap. 1).
  • Transparência de Localização: Recursos acessados sem saber sua posição física (ex.: URLs na web).
  • Transparência de Acesso: Interface uniforme para recursos locais ou remotos (ex.: API REST).
  • Transparência de Falha: Falhas mascaradas pelo sistema (ex.: replicação em bancos NoSQL).
  • Transparência de Concorrência: Acesso simultâneo sem conflitos (ex.: Google Docs com edição colaborativa).
  • Transparência de Replicação: Usuário não percebe múltiplas cópias de dados (ex.: CDN da Netflix).
• Tolerância a Falhas: Continuidade do serviço apesar de falhas (Tanenbaum Cap. 7).
  • Usa replicação (ex.: dados duplicados em Cassandra), redundância (ex.: servidores espelhados) e recuperação (ex.: checkpoints).
  • Exemplo prático: Amazon S3 mantém dados disponíveis mesmo com falhas em datacenters.
• Coordenação: Sincronização entre processos distribuídos (Silberschatz).
  • Mecanismos: algoritmos de eleição (ex.: Bully), consenso (ex.: Paxos, Raft), sincronização de relógios (ex.: NTP).
  • Exemplo prático: Zookeeper coordena nós em clusters Hadoop.
• Escalabilidade: Adaptação a cargas crescentes (Coulouris Cap. 1).
  • Vertical: Mais recursos por nó (ex.: upgrade de CPU).
  • Horizontal: Mais nós no sistema (ex.: adicionar servidores em um load balancer).
  • Exemplo prático: Google escala horizontalmente com milhares de servidores.
• Comunicação: Base para interação entre nós (Coulouris Cap. 4).
  • Mensagens (ex.: filas AMQP), RPC (ex.: gRPC), ou sockets (ex.: TCP/IP).
  • Exemplo prático: Kubernetes usa gRPC para comunicação entre pods.

Exemplos Práticos

• Internet: Rede global distribuída com bilhões de dispositivos (ex.: roteamento BGP entre ISPs).
• Bancos de Dados Distribuídos: Cassandra (alta disponibilidade), MongoDB (sharding), CockroachDB (consistência).
• Streaming de Vídeo: Netflix e YouTube usam CDNs para entrega escalável de conteúdo.
• Redes P2P: BitTorrent (compartilhamento de arquivos), Ethereum (blockchain distribuído).
• Computação em Nuvem: AWS (S3, EC2), Azure (Cosmos DB), GCP (BigQuery).
• Sistemas de Arquivos: Google File System (GFS) e Hadoop HDFS para armazenamento massivo.

Desafios dos Sistemas Distribuídos

• Consistência: Balancear disponibilidade e consistência (Teorema CAP – Coulouris Cap. 7). Ex.: Bancos NoSQL priorizam disponibilidade.
• Latência: Atrasos na comunicação entre nós (ex.: redes transatlânticas – Coulouris Cap. 3).
• Segurança: Criptografia e autenticação contra ataques (ex.: TLS em HTTPS – Tanenbaum Cap. 8).
• Gerenciamento de Falhas: Detecção e recuperação eficientes (ex.: heartbeat em clusters – Silberschatz).
• Complexidade: Dificuldade em projetar e depurar sistemas distribuídos (ex.: rastreamento de logs com ELK).

Responda as seguintes questões:

Responda as seguintes questões: