AsSkyMeet Docs

Visão Geral

v1.0.0-beta

Essa Documentação Está disponível apenas para visualização e estudos, todos os links e repositórios estão sendo desenvolvidos

Essa documentação serve para estudos, quando a os repositórios estiver disponíveis os desenvolvedores proderão usar para criar seus próprios aplicativos

A AsSkyMeet é uma rede social descentralizada que prioriza privacidade, controle do usuário e interoperabilidade entre servidores independentes. Esta documentação cobre desde a instalação até o desenvolvimento de extensões.

Como usuários, vivenciamos os desafios da centralização e censura nas redes sociais atuais. A AsSkyMeet devolve o controle dos seus dados e da sua privacidade a você, promovendo conexões genuínas e seguras.

Servidores Independente

Execute seu próprio nó e conecte-se a outros servidores via protocolo aberto. Cada servidor é independente mas pode se comunicar de forma segura.

Criptografia

Mensagens protegidas com criptografia. Suas Mensagens são criptografadas, sua privacidade é respeitada.

API Aberta

Desenvolva aplicativos e integrações com nossa API documentada. Use APIs abertas para criar experiências personalizadas.

Principais Benefícios

  • Controle total do seu conteúdo e compartilhamento
  • Gerencie seus próprios servidores, mídias e conteúdos
  • Monetize seu conteúdo diretamente com seus seguidores
  • Moderação comunitária para ambientes seguros e colaborativos
  • Sem anúncios, sem rastreamento - só você, sua rede e sua liberdade

Arquitetura

Visão Geral do Sistema

A AsSkyMeet opera em um modelo ASM Protocol, onde cada servidor (nó) pode se comunicar com outros através de um protocolo seguro. Esta arquitetura permite:

Componentes Principais

  • Núcleo (Core): Gerencia conexões e sincronização de dados
  • API Gateway: Interface REST/GraphQL para clientes
  • Banco de Dados: Armazenamento descentralizado
  • Serviço de Criptografia: Gerencia chaves e encriptação

Protocolos

  • ASM Protocol: Comunicação entre nós
  • OAuth 2.0: Autenticação e autorização
  • Webhooks: Comunicação entre nós e a rede global
  • SignalR WebSocket: Comunicação em tempo real

Diagrama de Arquitetura


  Client → API Gateway → Core → (Encriptação de Mensagens) → ASM Protocol
                      ↓           ↑
                  Banco de Dados ← Chaves de Criptografia
          

Fluxo de Publicação

  1. Cliente envia conteúdo via API
  2. Servidor valida e assina digitalmente
  3. As Mensagens são criptografadas
  4. Propagação para servidores federados
  5. Armazenamento local ou em cache Redis

Tecnologias Principais

C# .Net Core PostgreSQL Redis Node.js React-Native

SDKs Principais

Nodejs React-Native Python C# Kotlin Swift

Primeiros Passos

Como Começar

1. Criando uma Conta

Para começar a usar a AsSkyMeet, você pode se registrar em qualquer servidor disponível ou criar seu próprio nó.


  // Requisição para registro
  POST /api/v1/auth/register
  {
    "username": "novousuario",
    "email": "usuario@email.com",
    "password": "senhasegura123"
  }
              

2. Configurando seu Perfil

Após o registro, personalize seu perfil com informações básicas e preferências de privacidade.


  // Atualizando perfil
  PATCH /api/v1/users/@me
  {
    "display_name": "Meu Nome",
    "bio": "Entusiasta da liberdade digital",
    "privacy_level": "friends_only"
  }
              

Clientes Disponíveis

  • AsSkyMeet Web: Interface web oficial
  • AsSkyMeet Mobile: Apps para iOS e Android

Próximos Passos

  1. Conectar-se a amigos
  2. Explorar comunidades
  3. Criar seu primeiro servidor
  4. Personalizar configurações

API Reference

Endpoints Principais

POST /api/v1/auth/login

Autentica um usuário e retorna um token JWT.


  {
    "username": "seu_usuario",
    "password": "sua_senha"
  }
            

  // Resposta de sucesso
  {
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "expires_in": 3600,
    "user": {
      "id": "usr_123456789",
      "username": "seu_usuario",
      "display_name": "Seu Nome"
    }
  }
            
GET /api/v1/users/@me

Retorna os dados do usuário autenticado.


  GET /api/v1/users/@me HTTP/1.1
  Authorization: Bearer SEU_TOKEN_JWT
            
POST /api/v1/posts

Cria uma nova publicação.


  {
    "content": "Olá, mundo! Esta é minha primeira publicação na AsSkyMeet!",
    "visibility": "public",
    "attachments": []
  }
            

Códigos de Status

  • 200 OK: Requisição bem-sucedida
  • 201 Created: Recurso criado com sucesso
  • 400 Bad Request: Dados inválidos
  • 401 Unauthorized: Autenticação necessária
  • 404 Not Found: Recurso não encontrado

Limites de Taxa

  • 100 requisições/minuto por IP
  • 5 requisições/segundo por usuário autenticado
  • Headers de resposta incluem limites atuais:

  X-RateLimit-Limit: 100
  X-RateLimit-Remaining: 97
  X-RateLimit-Reset: 1625097600
            

Autenticação

Visão Geral

A AsSkyMeet utiliza OAuth 2.0 e JWT para autenticação. Todos os endpoints (exceto /auth) requerem um token de acesso válido no header Authorization.

Fluxo de Autenticação

  1. Cliente envia credenciais para /auth/login
  2. Servidor valida e retorna token JWT
  3. Cliente usa token em requisições subsequentes
  4. Token expira após 1 hora (renovável)

Tipos de Token

Access Token

Validade curta (1h), usado para requisições API

Refresh Token

Validade longa (7d), usado para obter novos access tokens

App Token

Para integrações de terceiros (validade configurável)

Exemplo Completo


  // 1. Obter token
  const response = await fetch('https://api.asskymeet.com/auth/login', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      username: 'meu_usuario',
      password: 'minha_senha_segura'
    })
  });
  
  const { token } = await response.json();
  
  // 2. Usar token em requisições autenticadas
  const profile = await fetch('https://api.asskymeet.com/users/@me', {
    headers: { 'Authorization': `Bearer ${token}` }
  });
          

Modelos de Dados

Estruturas Principais

Usuário (User)


  interface User {
    id: string;               // Identificador único
    username: string;         // Nome de usuário único
    display_name?: string;    // Nome de exibição
    email: string;            // Email (criptografado)
    bio?: string;             // Biografia do perfil
    avatar_url?: string;      // URL do avatar
    created_at: Date;         // Data de criação
    updated_at: Date;         // Data da última atualização
  }
              

Publicação (Post)


  interface Post {
    id: string;               // Identificador único
    author_id: string;        // ID do autor
    content: string;          // Conteúdo textual
    visibility: 'public' | 'friends_only' | 'private';
    attachments: Attachment[]; // Mídias anexadas
    likes_count: number;      // Número de curtidas
    comments_count: number;   // Número de comentários
    created_at: Date;         // Data de criação
  }
              

Servidor (ServerNode)


  interface ServerNode {
    id: string;               // Identificador único
    domain: string;           // Domínio do servidor
    name: string;             // Nome amigável
    description?: string;     // Descrição do servidor
    version: string;          // Versão do software
    users_count: number;      // Número de usuários
    is_public: boolean;       // Se aceita novos usuários
    created_at: Date;         // Data de registro
  }
              

Relacionamentos

  • User → Post: 1 para muitos
  • User → ServerNode: Muitos para muitos
  • ServerNode → ServerNode: Federação (grafo)

Tipos de Dados

  • UUID: Para identificadores únicos
  • DateTime: ISO 8601 (UTC)
  • EncryptedString: Para dados sensíveis

Self-Hosting

Guia de Instalação

Requisitos Mínimos

  • SO: Linux (Ubuntu 20.04+ recomendado)
  • CPU: 2 núcleos (4 recomendados)
  • RAM: 4GB (8GB recomendados)
  • Armazenamento: 20GB SSD (50GB recomendados)

Instalação Manual


  # 1. Instalar dependências
  sudo apt update && sudo apt install -y \
    git nodejs npm postgresql redis
  
  # 2. Clonar repositório
  git clone https://github.com/asskymeet/core.git
  cd core
  
  # 3. Instalar dependências do projeto
  npm install
  
  # 4. Configurar banco de dados
  sudo -u postgres psql -c "CREATE USER asskymeet WITH PASSWORD 'senha_segura';"
  sudo -u postgres psql -c "CREATE DATABASE asskymeet OWNER asskymeet;"
  
  # 5. Configurar .env
  cp .env.example .env
  nano .env  # Editar configurações
  
  # 6. Executar migrações
  npx knex migrate:latest
  
  # 7. Iniciar servidor
  npm run start
              

Configuração do .env


  # Configurações básicas
  NODE_ENV=production
  PORT=3000
  DOMAIN=meuservidor.com
  
  # Banco de dados
  DB_HOST=localhost
  DB_PORT=5432
  DB_USER=asskymeet
  DB_PASSWORD=senha_segura
  DB_NAME=asskymeet
  
  # Redis
  REDIS_HOST=localhost
  REDIS_PORT=6379
  
  # Segurança
  JWT_SECRET=segredo_muito_seguro
  ENCRYPTION_KEY=chave_de_32_bytes
  
  # Federação
  FEDERATION_ENABLED=true
  FEDERATION_DOMAIN=meuservidor.com
              

Configuração de Rede

  • Portas necessárias:
  • - TCP 3000 (HTTP)
  • - TCP 3001 (HTTPS)
  • - TCP 5432 (PostgreSQL)
  • - TCP 6379 (Redis)

Dicas de Produção

  • Use NGINX ou outro reverse proxy
  • Configure HTTPS com Let's Encrypt
  • Monitore com PM2 ou systemd
  • Faça backups regulares do banco de dados

Docker

Instalação com Docker

Pré-requisitos

  • Docker Engine 20.10+
  • Docker Compose 1.29+
  • 4GB RAM disponível

Iniciando com Docker Compose


  # 1. Baixar docker-compose.yml
  curl -O https://raw.githubusercontent.com/asskymeet/core/main/docker-compose.yml
  
  # 2. Configurar .env
  cp .env.example .env
  nano .env  # Editar configurações
  
  # 3. Iniciar containers
  docker-compose up -d
  
  # 4. Executar migrações
  docker-compose exec app npx knex migrate:latest
  
  # 5. Acessar em http://localhost:3000
              

Arquivo docker-compose.yml


  version: '3.8'
  
  services:
    app:
      image: asskymeet/core:latest
      restart: unless-stopped
      ports:
        - "3000:3000"
      environment:
        - NODE_ENV=production
        - DB_HOST=db
        - REDIS_HOST=redis
      depends_on:
        - db
        - redis
      volumes:
        - ./uploads:/app/uploads
  
    db:
      image: postgres:13
      restart: unless-stopped
      environment:
        POSTGRES_USER: asskymeet
        POSTGRES_PASSWORD: senha_segura
        POSTGRES_DB: asskymeet
      volumes:
        - pg_data:/var/lib/postgresql/data
  
    redis:
      image: redis:6
      restart: unless-stopped
      volumes:
        - redis_data:/data
  
  volumes:
    pg_data:
    redis_data:
              

Comandos Úteis


  # Ver logs do aplicativo
  docker-compose logs -f app
  
  # Parar todos os containers
  docker-compose down
  
  # Fazer backup do banco de dados
  docker-compose exec db pg_dump -U asskymeet asskymeet > backup.sql
  
  # Atualizar para a versão mais recente
  docker-compose pull
  docker-compose up -d
            

Configuração Avançada

  • Adicione um reverse proxy para HTTPS
  • Configure volumes para persistência
  • Defina limites de recursos (CPU/RAM)
  • Use .env para configurações sensíveis

Escalabilidade

Arquitetura Escalável

Estratégias de Escalonamento

  • Horizontal: Adicione mais instâncias do aplicativo
  • Vertical: Aumente recursos da máquina
  • Read Replicas: Para o banco de dados
  • Sharding: Particione dados por região/usuário

Configuração para Alta Demanda


  # Exemplo de docker-compose para múltiplas instâncias
  version: '3.8'
  
  services:
    app:
      image: asskymeet/core:latest
      deploy:
        replicas: 3
        resources:
          limits:
            cpus: '0.5'
            memory: 512M
      environment:
        - NODE_ENV=production
        - CLUSTER_MODE=true
        - REDIS_HOST=redis
  
    loadbalancer:
      image: nginx
      ports:
        - "80:80"
        - "443:443"
      volumes:
        - ./nginx.conf:/etc/nginx/nginx.conf
  
    db:
      image: postgres:13
      environment:
        POSTGRES_USER: asskymeet
        POSTGRES_PASSWORD: senha_segura
        POSTGRES_DB: asskymeet
      volumes:
        - pg_data:/var/lib/postgresql/data
  
    redis:
      image: redis:6
      volumes:
        - redis_data:/data
  
  volumes:
    pg_data:
    redis_data:
              

Monitoramento

  • Prometheus + Grafana: Para métricas
  • ELK Stack: Para logs
  • Health Checks: /health endpoint

Melhores Práticas

  • Use CDN para mídias estáticas
  • Implemente cache em múltiplos níveis
  • Considere serverless para funções específicas

FAQ

Perguntas Frequentes

1. Como a AsSkyMeet difere de outras redes sociais descentralizadas?

A AsSkyMeet combina os melhores aspectos das redes Globals com um foco especial em privacidade e controle do usuário. Diferente de outras soluções, oferecemos: - Monetização direta entre criadores e seguidores - Controle granular de privacidade - Compatibilidade com múltiplos protocolos - Foco em comunidades auto-geridas

2. Posso migrar meu servidor de outra plataforma?

Sim, oferecemos ferramentas de migração para várias plataformas. O processo geralmente envolve: 1. Exportar seus dados da plataforma atual 2. Converter para o formato AsSkyMeet usando nosso conversor 3. Importar para seu novo servidor Consulte nossa documentação de migração para instruções específicas.

3. Como a AsSkyMeet se sustenta financeiramente?

Acreditamos em um modelo sustentável que não explore os usuários: - Doações voluntárias - Serviços premium opcionais (como servidores gerenciados) - Parcerias com organizações alinhadas com nossos valores - Nenhum anúncio ou venda de dados O código principal sempre permanecerá aberto e gratuito.

Solução de Problemas

Problemas de Conexão Global

Se seu servidor não está se conectando com outros nós:

  • Verifique se a rede global está habilitada no .env
  • Confira as configurações de firewall/portas
  • Valide o DNS do seu domínio
  • Verifique os logs do servidor para erros

Problemas de Performance

Se o servidor está lento:

  • Verifique a utilização de recursos (CPU, RAM, disco)
  • Otimize as configurações do banco de dados
  • Considere adicionar mais instâncias ou um cache Redis
  • Verifique por queries lentas

Suporte

Obtendo Ajuda

Documentação

Consulte nossa documentação detalhada para respostas rápidas.

Explorar Docs →

Comunidade

Junte-se à nossa comunidade para ajuda de outros usuários.

Entrar no Discord →

Reportar Bugs

Encontrou um problema? Reporte no nosso GitHub.

Abrir Issue →