El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

Introducció

En aquest cas d'estudi, explorarem com dissenyar una arquitectura robusta i escalable per a una aplicació de xarxes socials. Les aplicacions de xarxes socials tenen requisits únics, com la gestió de grans volums de dades, la necessitat de temps de resposta ràpids i la capacitat de suportar un gran nombre d'usuaris simultanis. A més, la seguretat i la privacitat de les dades són aspectes crítics.

Requisits del Sistema

Abans de dissenyar l'arquitectura, és important definir els requisits del sistema:

Funcionalitats bàsiques:
- Registre i autenticació d'usuaris.
- Creació, edició i eliminació de perfils d'usuari.
- Publicació, edició i eliminació de contingut (text, imatges, vídeos).
- Interacció amb el contingut (m'agrada, comentaris, comparticions).
- Sistema de missatgeria privada.
- Notificacions en temps real.
Requisits no funcionals:
- Escalabilitat: Capacitat per gestionar milions d'usuaris.
- Rendiment: Temps de resposta ràpids.
- Disponibilitat: Alta disponibilitat (99.9% o superior).
- Seguretat: Protecció de dades personals i autenticació segura.
- Privacitat: Compliment de regulacions com el GDPR.

Arquitectura Proposada

Capes de l'Arquitectura

L'arquitectura de l'aplicació es dividirà en diverses capes per assegurar la modularitat i la facilitat de manteniment:

Capa de Presentació: Interfície d'usuari (UI) que interactua amb els usuaris finals.
Capa de Serveis: Lògica de negoci i serveis d'aplicació.
Capa de Persistència: Gestió de dades i emmagatzematge.
Capa de Seguretat: Autenticació, autorització i protecció de dades.
Capa de Comunicació: Gestió de la comunicació entre serveis i components.

Components Clau

a. Frontend

Tecnologies: React.js, Angular, Vue.js
Funcionalitats: Interfície d'usuari per a la interacció amb l'aplicació.

b. Backend

Tecnologies: Node.js, Express, Spring Boot
Funcionalitats: API RESTful per gestionar les operacions de l'aplicació.

c. Base de Dades

Tecnologies: PostgreSQL (per a dades relacionals), MongoDB (per a dades no relacionals)
Funcionalitats: Emmagatzematge de dades d'usuaris, publicacions, comentaris, etc.

d. Serveis de Missatgeria

Tecnologies: RabbitMQ, Kafka
Funcionalitats: Gestió de missatges i notificacions en temps real.

e. Emmagatzematge de Contingut

Tecnologies: Amazon S3, Google Cloud Storage
Funcionalitats: Emmagatzematge d'imatges, vídeos i altres continguts multimèdia.

f. Autenticació i Autorització

Tecnologies: OAuth 2.0, JWT (JSON Web Tokens)
Funcionalitats: Gestió de sessions d'usuari i permisos d'accés.

Diagrama d'Arquitectura

+-------------------+        +-------------------+        +-------------------+
|    Frontend       | <----> |      Backend      | <----> |    Base de Dades  |
| (React.js, etc.)  |        | (Node.js, etc.)   |        | (PostgreSQL, etc.)|
+-------------------+        +-------------------+        +-------------------+
        |                         |                         |
        v                         v                         v
+-------------------+        +-------------------+        +-------------------+
|  Serveis de Miss. | <----> | Emmagatzematge    | <----> | Autenticació      |
| (RabbitMQ, etc.)  |        | (Amazon S3, etc.) |        | (OAuth 2.0, etc.) |
+-------------------+        +-------------------+        +-------------------+

Exemples Pràctics

Implementació d'una API RESTful per a la Publicació de Contingut

Endpoint: Crear una Publicació

URL: /api/posts

Mètode: POST

Request Body:

{
  "userId": "12345",
  "content": "Aquest és un nou post!",
  "mediaUrl": "http://example.com/image.jpg"
}

Resposta:

{
  "postId": "67890",
  "userId": "12345",
  "content": "Aquest és un nou post!",
  "mediaUrl": "http://example.com/image.jpg",
  "timestamp": "2023-10-01T12:34:56Z"
}

Codi Backend (Node.js amb Express):

const express = require('express');
const app = express();
app.use(express.json());

app.post('/api/posts', (req, res) => {
  const { userId, content, mediaUrl } = req.body;
  const postId = generateUniqueId();
  const timestamp = new Date().toISOString();

  // Aquí es guardaria la publicació a la base de dades
  const newPost = { postId, userId, content, mediaUrl, timestamp };
  // db.save(newPost);

  res.status(201).json(newPost);
});

function generateUniqueId() {
  return Math.random().toString(36).substr(2, 9);
}

app.listen(3000, () => {
  console.log('Servidor en funcionament al port 3000');
});

Implementació de Notificacions en Temps Real

Tecnologies: Socket.IO (per a Node.js)

Codi Backend (Node.js amb Socket.IO):

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

io.on('connection', (socket) => {
  console.log('Nou usuari connectat');

  socket.on('newPost', (post) => {
    io.emit('newPost', post);
  });

  socket.on('disconnect', () => {
    console.log('Usuari desconnectat');
  });
});

server.listen(3000, () => {
  console.log('Servidor en funcionament al port 3000');
});

Exercici Pràctic

Implementació d'un Sistema de Missatgeria

Requisits:

Crear un endpoint per enviar missatges.
Utilitzar una cua de missatges (RabbitMQ) per gestionar els missatges.
Implementar una interfície d'usuari per enviar i rebre missatges en temps real.

Solució:

Backend (Node.js amb RabbitMQ):

Instal·lació de RabbitMQ:

npm install amqplib

Codi Backend:

const amqp = require('amqplib/callback_api');

amqp.connect('amqp://localhost', (err, connection) => {
  if (err) throw err;

  connection.createChannel((err, channel) => {
    if (err) throw err;

    const queue = 'messages';

    channel.assertQueue(queue, { durable: false });

    app.post('/api/messages', (req, res) => {
      const { senderId, receiverId, message } = req.body;
      const msg = JSON.stringify({ senderId, receiverId, message });

      channel.sendToQueue(queue, Buffer.from(msg));
      res.status(200).send('Missatge enviat');
    });

    channel.consume(queue, (msg) => {
      const message = JSON.parse(msg.content.toString());
      console.log('Missatge rebut:', message);
      // Aquí es podria enviar el missatge a la interfície d'usuari
    }, { noAck: true });
  });
});

Frontend (React.js amb Socket.IO):

Instal·lació de Socket.IO:

npm install socket.io-client

Codi Frontend:

import React, { useState, useEffect } from 'react';
import io from 'socket.io-client';

const socket = io('http://localhost:3000');

function Chat() {
  const [message, setMessage] = useState('');
  const [messages, setMessages] = useState([]);

  useEffect(() => {
    socket.on('newMessage', (msg) => {
      setMessages((prevMessages) => [...prevMessages, msg]);
    });

    return () => {
      socket.off('newMessage');
    };
  }, []);

  const sendMessage = () => {
    socket.emit('newMessage', message);
    setMessage('');
  };

  return (
    <div>
      <h1>Chat</h1>
      <div>
        {messages.map((msg, index) => (
          <div key={index}>{msg}</div>
        ))}
      </div>
      <input
        type="text"
        value={message}
        onChange={(e) => setMessage(e.target.value)}
      />
      <button onClick={sendMessage}>Enviar</button>
    </div>
  );
}

export default Chat;

Conclusió

Aquest cas d'estudi ha proporcionat una visió general de com dissenyar una arquitectura per a una aplicació de xarxes socials, incloent-hi els components clau, les tecnologies utilitzades i exemples pràctics d'implementació. La modularitat, l'escalabilitat i la seguretat són aspectes crítics que s'han de tenir en compte en el disseny d'aquest tipus d'aplicacions. Amb aquesta base, els estudiants poden començar a desenvolupar les seves pròpies aplicacions de xarxes socials robustes i escalables.

Arquitectures de Sistemes: Principis i Pràctiques per Dissenyar Arquitectures Tecnològiques Robustes i Escalables

Cas d'Estudi: Arquitectura d'una Aplicació de Xarxes Socials