LTSP (Linux Terminal Server Project) é um projeto open source que permite a execução de múltiplas sessões de usuários, com processamento centralizado em um único servidor Linux.

Em vez de computadores completos, os usuários utilizam Thin Clients — máquinas simples, com pouco poder de processamento, que apenas exibem a interface gráfica e enviam comandos de entrada (mouse/teclado).

Funcionamento do LTSP

• O servidor LTSP executa todas as aplicações (LibreOffice, navegadores, etc.).
• O cliente leve se conecta via rede (geralmente PXE boot), carrega uma imagem mínima e inicia uma sessão remota no servidor.
• A comunicação ocorre por protocolos como SSH, X11 ou VNC.

Esquema Ilustrativo

Vantagens do LTSP

• Redução de custos: Thin clients podem ser reaproveitados de máquinas antigas.
• Manutenção centralizada: Apenas o servidor precisa de atualizações e configuração de softwares.
• Segurança: Os dados e aplicações estão centralizados.
• Eficiência energética: Menor consumo em comparação a PCs tradicionais.

Aplicações Reais

• Laboratórios escolares e universitários com orçamento limitado.
• Ambientes corporativos com terminais para atendimento ao cliente (bancos, repartições públicas).
• Telecentros, bibliotecas e centros comunitários.

Comparação com Outros Modelos

• LTSP vs. Virtualização: LTSP oferece sessões independentes para usuários, mas todos os processos rodam diretamente no servidor, sem uma VM por usuário.
• LTSP vs. VDI (Virtual Desktop Infrastructure): VDI geralmente usa máquinas virtuais para cada usuário, o que exige mais recursos.

Sistemas Operacionais Compatíveis

• Distribuições Linux com suporte a LTSP: Ubuntu, Debian, Fedora, openSUSE.
• LTSP moderno (versão 20+): Compatível com Ubuntu 20.04+ e Debian 11+, com suporte a ltsp-manager e imagens baseadas em systemd-nspawn.

Arquitetura de um Cluster

Head Node (Gerenciador) Compute Nodes (Tarefas Paralelas) Storage (Lustre, NFS) Rede (Infiniband/100Gbps)

• Head Node: Agenda tarefas (SLURM, PBS) e gerencia usuários.
• Compute Nodes: Nós homogêneos ou heterogêneos (CPU/GPU).
• Comunicação: Latência ultrabaixa (Infiniband) ou Ethernet.

Stack Tecnológico

Clusters na Prática

O Futuro: Cloud HPC e Edge Clustering

Grid vs. Cluster: Principais Diferenças

Arquitetura de um Grid

Middleware (Globus Toolkit) Recursos Distribuídos Usuário Final

• Middleware: Camada de software que unifica recursos heterogêneos (ex: Globus Toolkit).
• Segurança: Autenticação federada (certificados X.509).

Projetos Famosos de Grid Computing

O Futuro do Grid Computing

Arquitetura: Cloud vs. Fog vs. Edge

Exemplo: Em uma fábrica inteligente, sensores (edge) enviam dados para um gateway (fog) que filtra informações antes de enviar à nuvem.

Aplicações Práticas

Fog vs. Cloud: Quando Usar?

Desafios e Tendências

Evolução Histórica

Comparativo Detalhado

Quem Usa e Como?

Tendências Emergentes

Arquitetura CORBA

IDL (Interface Definition Language)

ORB (Object Request Broker)

IIOP (Protocolo de Rede)

• IDL: Linguagem neutra para definir interfaces (compilável para Java, C++, etc.).
• ORB: "Middleware" que roteia chamadas entre objetos.
• IIOP: Protocolo binário sobre TCP/IP (alternativa ao DCE-RPC).

Exemplo Prático: IDL + Java

// Calculator.idl
module Calculadora {
  interface Operacoes {
    double soma(in double a, in double b);
    double subtrai(in double a, in double b);
  };
};

// Servidor Java
public class OperacoesImpl extends OperacoesPOA {
  public double soma(double a, double b) {
    return a + b;
  }
  // ... outras implementações
}

Onde CORBA ainda é Usado?

Arquitetura MPI

MPI_Send(buffer, count, datatype, dest, tag, comm);
MPI_Recv(buffer, count, datatype, source, tag, comm, status);

MPI_Bcast(data, count, datatype, root, comm);
MPI_Reduce(sendbuf, recvbuf, count, datatype, op, root, comm);

Exemplo Prático: "Hello World" em MPI

#include <mpi.h>
#include <stdio.h>

int main(int argc, char** argv) {
  MPI_Init(&argc, &argv);
  
  int rank, size;
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  MPI_Comm_size(MPI_COMM_WORLD, &size);
  
  printf("Hello from rank %d of %d\n", rank, size);
  
  MPI_Finalize();
  return 0;
}

from mpi4py import MPI

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()

print(f"Hello from rank {rank} of {size}")

Onde MPI Brilha?

Supercomputadores

Fugaku (Japão): 7.3M núcleos usando MPI+OpenMP.

Modelagem Climática

CESM (EUA): Simulações com 100+ variáveis em paralelo.

MPI vs. Outras Abordagens

Arquitetura OpenMP

Thread 1
Núcleo 1

Thread 2
Núcleo 2

Thread 3
Núcleo 3

Thread 4
Núcleo 4

Memória Compartilhada

• Escopo de Variáveis: private (cópia por thread) ou shared (acesso concorrente).
• Diretivas-Chave: #pragma omp parallel, for, reduction.

Exemplos Práticos

Cálculo de π Soma de Vetor

Método de Monte Carlo

π ≈ 4 × (pontos dentro do círculo / pontos totais). Paralelize a geração de pontos:

Serial Paralelo

#include <stdio.h>
#include <stdlib.h>

int main() {
  int points = 1e6;
  int inside = 0;
  
  for (int i = 0; i < points; i++) {
    double x = (double)rand() / RAND_MAX;
    double y = (double)rand() / RAND_MAX;
    if (x*x + y*y <= 1) inside++;
  }
  
  double pi = 4.0 * inside / points;
  printf("π ≈ %f\n", pi);
  return 0;
}

#include <omp.h>
// ...
  #pragma omp parallel for reduction(+:inside)
  for (int i = 0; i < points; i++) {
    // Geração de pontos (igual ao serial)
  }
  printf("π ≈ %f (%d threads)\n", pi, omp_get_max_threads());

Compilação: gcc -fopenmp pi.c -o pi && OMP_NUM_THREADS=4 ./pi

Soma de Elementos de Vetor

Paralelize a soma de um vetor grande usando reduction:

Serial Paralelo

double sum = 0;
for (int i = 0; i < N; i++) {
  sum += array[i];
}

double sum = 0;
#pragma omp parallel for reduction(+:sum)
for (int i = 0; i < N; i++) {
  sum += array[i];
}

Compilação: gcc -fopenmp sum.c -o sum

Análise de Desempenho

double result[N];
for (int i = 0; i < N; i++) {
  result[i] = 0;
  for (int j = 0; j < N; j++) {
    result[i] += matrix[i][j] * vector[j];
  }
}

#pragma omp parallel for
for (int i = 0; i < N; i++) {
  result[i] = 0;
  #pragma omp simd  // Otimização adicional
  for (int j = 0; j < N; j++) {
    result[i] += matrix[i][j] * vector[j];
  }
}

Como Funciona?

Cliente

Servidor

HTTP/2

Protocol Buffers

• Protocol Buffers: Estrutura de dados binária (menor que JSON).
• HTTP/2: Multiplexação, compressão de cabeçalhos.
• Stubs Gerados: Código em múltiplas linguagens (Go, Python, Java...).

Exemplo: Serviço de Calculadora

syntax = "proto3";

service Calculator {
  rpc Add (AddRequest) returns (AddResponse);
}

message AddRequest {
  int32 a = 1;
  int32 b = 2;
}

message AddResponse {
  int32 result = 1;
}

package main

import (
  "context"
  "log"
  "net"

  "google.golang.org/grpc"
  pb "caminho/do/proto"
)

type server struct{}

func (s *server) Add(ctx context.Context, req *pb.AddRequest) (*pb.AddResponse, error) {
  return &pb.AddResponse{Result: req.A + req.B}, nil
}

func main() {
  lis, _ := net.Listen("tcp", ":50051")
  s := grpc.NewServer()
  pb.RegisterCalculatorServer(s, &server{})
  s.Serve(lis)
}

import grpc
import calculator_pb2
import calculator_pb2_grpc

channel = grpc.insecure_channel('localhost:50051')
stub = calculator_pb2_grpc.CalculatorStub(channel)

response = stub.Add(calculator_pb2.AddRequest(a=5, b=3))
print("Resultado:", response.result)  # Output: 8

gRPC vs REST

Quem Usa gRPC?

Netflix

Comunicação entre microsserviços (1B+ requisições/dia).

Google

Originalmente criado para conectar serviços na nuvem.

service Chat {
  rpc SendMessage (stream Message) returns (stream MessageResponse);
}

Como o NFS Funciona?

Cliente

Servidor

RPC/XDR

VFS (Virtual File System)

• VFS: Camada que abstrai operações de arquivo (open, read, etc.).
• XDR: Padroniza representação de dados entre sistemas heterogêneos.
• Stateless: NFSv3 não mantém estado (simplicidade, mas exige cache no cliente).

Configuração em Linux

# Instale o NFS no servidor (Ubuntu)
sudo apt install nfs-kernel-server

# Configure o diretório exportado
sudo mkdir /shared
sudo chown nobody:nogroup /shared
echo "/shared *(rw,sync,no_subtree_check)" | sudo tee /etc/exports

# Inicie o serviço
sudo exportfs -a
sudo systemctl start nfs-kernel-server

# Instale o cliente NFS
sudo apt install nfs-common

# Monte o diretório remoto
sudo mkdir -p /mnt/nfs/shared
sudo mount -t nfs servidor:/shared /mnt/nfs/shared

# Verifique
df -h | grep nfs
ls /mnt/nfs/shared  # Arquivos aparecem como locais!

Evolução do Protocolo

Aplicações no Mundo Real

Clusters HPC

Compartilhamento de datasets grandes entre nós de computação.

Virtualização

Armazenamento centralizado para máquinas virtuais.

servidor:/shared  /mnt/nfs/shared  nfs  defaults  0  0

Heterogeneidade em Sistemas Distribuídos

Definição: Capacidade de integrar diferentes tecnologias em um mesmo sistema:

• Sistemas Operacionais: Windows, Linux, macOS, Android, iOS trabalhando juntos
• Arquiteturas de Hardware: x86, ARM, GPUs, TPUs, dispositivos com diferentes capacidades
• Linguagens de Programação: Microserviços em Java, Python, Go, Node.js comunicando-se
• Protocolos de Comunicação: HTTP/REST, gRPC, MQTT, WebSockets coexistindo

Computação Ubíqua (Pervasiva)

Conceito: Tecnologia integrada ao ambiente do usuário, invisível e disponível em qualquer lugar:

• Dispositivos Pessoais: Smartwatches (monitoramento contínuo de saúde), fones inteligentes
• Casa Inteligente: Alexa/Google Home, lâmpadas e termostatos conectados
• Cidades Inteligentes: Sensores de tráfego, iluminação pública adaptativa
• Indústria 4.0: Sensores em equipamentos, manutenção preditiva
• Saúde: Wearables médicos, implantes monitorados remotamente

Simpósio Brasileiro de Redes de Computadores e Sistemas Distribuídos (SBRC)

• Evento anual promovido pela SBC e LARC.
• Mais importante evento de pesquisa no Brasil em Redes e Sistemas Distribuídos.
• Acontece desde 1983, com publicações de artigos científicos, tutoriais, minicursos, etc.

Bibliografia Básica

• Coulouris, G., et al. Distributed Systems: Concepts and Design.
• Tanenbaum, A. S., & Van Steen, M. Distributed Systems: Principles and Paradigms.
• Lynch, N. A. Distributed Algorithms.
• Attiya, H. & Welch, J. Distributed Computing.

Responda as seguintes questões:

Responda as seguintes questões: