creación de un sistema que captura datos, los almacena, los procesa como Markdown y los transforma en un sitio web con buscador

Fase 0: El Ecosistema (Las Herramientas)

Para que todo funcione en Ubuntu sin conflictos, utilizaremos:

  • Rust (Lenguaje): El motor de lógica.
  • Docker & Docker Compose: Para encapsular la Base de Datos y la App.
  • PostgreSQL (DB): Donde vive la "verdad" de tus datos.
  • Axum (Framework Web): Para el servidor y el formulario.
  • SQLx: Para que Rust hable con Postgres de forma segura.
  • Tera & Pulldown-cmark: Para la magia de Markdown a HTML.

Fase 1: Arquitectura del Proyecto

La organización de carpetas es vital en Rust. Tu proyecto se verá así: Plaintext

mi_proyecto/
├── docker-compose.yml     # Orquestador de contenedores
├── Dockerfile             # Receta para la imagen de Rust
├── Cargo.toml             # Librerías (dependencias)
├── src/
│   └── main.rs            # Lógica principal del servidor
├── templates/             # Plantillas HTML (Zola style)
│   └── post.html
└── static/                # Archivos públicos (CSS, Imágenes)
    └── index.html         # El formulario original

Fase 2: El Modelo de Datos (PostgreSQL)

Antes de programar, definimos la tabla. En Rust, esto se traduce en un Struct.

La Tabla SQL: SQL

CREATE TABLE paginas (
    id SERIAL PRIMARY KEY,
    titulo TEXT NOT NULL,
    slug TEXT UNIQUE NOT NULL,      -- El "path" de la URL
    contenido_md TEXT NOT NULL,     -- El cuerpo del mensaje
    tags TEXT[],                   -- Taxonomías (Array de etiquetas)
    fecha_creacion TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

El Struct en Rust:

Usamos serde para el formulario y sqlx para la base de datos. Rust

#[derive(serde::Deserialize, sqlx::FromRow)]
struct Pagina {
    titulo: String,
    contenido_md: String,
    tags: String, // Recibimos "etiqueta1, etiqueta2"
}

Fase 3: El Servidor y el Formulario (Axum)

Configuramos Axum para que escuche en el puerto 3000.

GET /: Sirve el index.html con tu imagen y los campos.

POST /generar:
    Recibe los datos del formulario.
    Genera un Slug (ej: de "Hola Mundo" a "hola-mundo").
    Guarda en PostgreSQL.
    Escribe un archivo .md físico en el disco (usando std::fs).

Fase 4: La Transformación (Markdown a HTML)

Aquí es donde imitamos a Zola. Creamos una función que:

  • Toma el texto Markdown de la base de datos.

  • Lo pasa por pulldown-cmark para obtener HTML puro.

  • Carga una plantilla de la carpeta templates/ usando la librería Tera.

  • Fusiona el HTML con la plantilla para crear la página final.

      Rust

  // Ejemplo de lógica de transformación
  let parser = Parser::new(&contenido_markdown);
  let mut html_output = String::new();
  html::push_html(&mut html_output, parser);

Fase 5: El Buscador

Para el buscador, añadiremos una ruta nueva en Axum: GET /buscar?q=....

  • Rust toma el parámetro q.
  • Hace una consulta a Postgres usando ILIKE o tsvector (Full Text Search).
  • Devuelve los resultados como JSON al navegador.

Fase 6: Despliegue con Docker Compose

Para ejecutar todo, solo necesitarás un comando. El archivo docker-compose.yml unirá la base de datos y tu código de Rust.

YAML

services:
db:
    image: postgres:15
    environment:
    POSTGRES_PASSWORD: password
app:
    build: .
    ports:
    - "3000:3000"
    depends_on:
    - db

Resumen de Pasos para cuando estés listo:

  • Instalar Docker en tu Ubuntu.
  • Definir tus campos: (Título, Autor, Tags, etc.).
  • Configurar el Cargo.toml con las librerías que mencionamos.
  • Escribir el main.rs siguiendo los bloques de lógica (Conexión BD -> Servidor -> Procesamiento).
  • Ejecutar docker-compose up y empezar a rellenar formularios.

Esta guía es tu cimiento. Tienes que definir los campos exactos de tu formulario, y escribir el código específico para cada uno de ellos.