Blog Tinux Net

Frontends, Backends & Linux Servers

En este Blog se trabajara sobre el trabajo diario de Desarrollo con Servidores y Web Developer
  • Publicado en

    Tailwind 4.1

    Evolucion al nuevo modelo.

    Importante: Hay muchos cambios en la estructura y en la forma de ejecutar los scripts para la renderizacion del css

    Mucho mas facil de realizar. Pero tambien exige un minimo de organizacion para le desarrollador

    Instalacion.

    • Install Tailwind CSS Install tailwindcss and @tailwindcss/cli via npm.
    npm install tailwindcss @tailwindcss/cli
    • Configurar el archivo de iniciacion: Importar Tailwind en tu CSS Añadir el @import "tailwindcss"; importar a tu estructura del fichero CSS.

    El oficial que se sugiere es ~/src/input.css aunque personalmente lo configuro en mi estructura, ~/assets/src/tailwind.css

    @import "tailwindcss";
    • Iniciar el proceso de compilación (renderizado) de Tailwind CLI Ejecutar la herramienta CLI para escanear los archivos fuente en busca de clases y crear el CSS.

    Los ficheros de entrada y salida son los de mis estructuras habituales de assets

    El oficial:

    npx @tailwindcss/cli -i ./src/input.css -o ./src/output.css --watch

    El de mi infraestructura:

    npx @tailwindcss/cli -i ./assets/src/tailwind.css -o ./assets/css/styles.css --watch

    El --watch es el que renderiza y y evalua en tiempo real si se ha producido cualquie modigicacion en las paginas o archivos dependientes de los css.

    • Empezaa a usar Tailwind en el HTML Añade tu archivo CSS compilado al y empieza a usar las clases de utilidad de Tailwind para dar estilo a tu contenido.
    <!doctype html>
<html>
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <link href="./assets/css/styles.css" rel="stylesheet">
</head>
<body>
  <h1 class="text-3xl font-bold underline">
    Hello world!
  </h1>
</body>
</html>
  • Publicado en

    Sí, en Tailwind CSS puedes reducir el tamaño de la fuente de un elemento dentro de un contenedor div utilizando las clases de utilidad para el tamaño de la fuente (text-*). Tailwind ofrece una amplia gama de tamaños de fuente predefinidos, pero también puedes personalizar el tamaño de la fuente en unidades específicas (como px, rem, em, etc.) utilizando valores arbitrarios.

    1. Usar tamaños de fuente predefinidos de Tailwind

    Tailwind incluye clases como text-sm, text-base, text-lg, etc., que representan tamaños de fuente predefinidos. Por ejemplo:

    <div class="container mx-auto p-4">
  <p class="text-lg">Este es un texto con tamaño de fuente grande.</p>
  <p class="text-sm">Este es un texto con tamaño de fuente pequeño.</p>
</div>
    • text-lg: Tamaño de fuente grande (1.125rem).
    • text-sm: Tamaño de fuente pequeño (0.875rem).

    2. Reducir la fuente en unidades específicas (valores arbitrarios)

    Si necesitas un tamaño de fuente específico que no está predefinido en Tailwind, puedes usar la notación de valores arbitrarios con corchetes ([]). Por ejemplo, para reducir la fuente en 2px:

    <div class="container mx-auto p-4">
  <p class="text-[14px]">Este texto tiene un tamaño de fuente de 14px.</p>
</div>
    • text-[14px]: Define un tamaño de fuente personalizado de 14px.

    3. Reducir la fuente en relación con el tamaño base

    Si deseas reducir la fuente en relación con el tamaño base de Tailwind (1rem o 16px), puedes usar unidades relativas como rem o em. Por ejemplo:

    <div class="container mx-auto p-4">
  <p class="text-[0.875rem]">Este texto tiene un tamaño de fuente de 0.875rem (14px).</p>
</div>
    • text-[0.875rem]: Define un tamaño de fuente personalizado de 0.875rem (equivalente a 14px).

    4. Reducir la fuente en dispositivos específicos (responsive)

    Puedes combinar las clases de tamaño de fuente con las clases responsivas de Tailwind para ajustar el tamaño de la fuente en diferentes dispositivos. Por ejemplo:

    <div class="container mx-auto p-4">
  <p class="text-base md:text-sm lg:text-[12px]">
    Este texto cambia de tamaño en diferentes dispositivos.
  </p>
</div>
    • text-base: Tamaño de fuente base en móviles (1rem o 16px).
    • md:text-sm: Tamaño de fuente pequeño en tablets (0.875rem o 14px).
    • lg:text-[12px]: Tamaño de fuente personalizado en pantallas grandes (12px).

    5. Reducir la fuente usando em o %

    Si prefieres usar unidades relativas como em o %, también puedes hacerlo con valores arbitrarios:

    <div class="container mx-auto p-4">
  <p class="text-[0.8em]">Este texto tiene un tamaño de fuente de 0.8em.</p>
  <p class="text-[80%]">Este texto tiene un tamaño de fuente del 80%.</p>
</div>
    • text-[0.8em]: Reduce la fuente al 80% del tamaño base.
    • text-[80%]: Reduce la fuente al 80% del tamaño base.

    6. Ejemplo completo

    Aquí tienes un ejemplo completo que combina todo lo anterior:

    <div class="container mx-auto p-4">
  <p class="text-lg md:text-base lg:text-[14px]">
    Este texto es responsive y se reduce en dispositivos más pequeños.
  </p>
  <p class="text-[12px]">
    Este texto tiene un tamaño fijo de 12px.
  </p>
</div>

    Resumen:

    • Usa clases predefinidas como text-sm, text-base, etc., para tamaños de fuente comunes.
    • Usa valores arbitrarios (text-[14px], text-[0.875rem], etc.) para tamaños personalizados.
    • Combina con clases responsivas (md:text-sm, lg:text-[12px], etc.) para ajustar el tamaño en diferentes dispositivos.

    Este enfoque te permite controlar el tamaño de la fuente de manera precisa y flexible en Tailwind CSS. ¡Espero que te sea útil! 😊

  • Publicado en

    Para crear una imagen responsive con Tailwind CSS, el método más adecuado es utilizar las utilidades de Tailwind para ajustar el tamaño, la posición y el comportamiento de la imagen en diferentes dispositivos. Aquí te explico el enfoque más eficiente y moderno:

    Método recomendado:

    1. Usar w-full para el ancho:

      • Esto hace que la imagen ocupe el 100% del ancho de su contenedor, adaptándose al tamaño de la pantalla.

    2. Usar h-auto para la altura:

      • Esto mantiene la proporción de la imagen, evitando que se distorsione.

    3. Usar object-cover o object-contain:

      • object-cover: La imagen cubre todo el espacio disponible, recortándose si es necesario.
      • object-contain: La imagen se ajusta completamente dentro del contenedor, sin recortarse.

    4. Ajustar el tamaño máximo con max-w-*:

      • Limita el tamaño máximo de la imagen para que no se vea demasiado grande en pantallas grandes.

    5. Usar clases responsivas:

      • Tailwind permite aplicar estilos diferentes dependiendo del tamaño de la pantalla (por ejemplo, md:w-1/2 para tablets).

    Código de ejemplo:

    <img
  src="ruta/a/tu/imagen.jpg"
  alt="Descripción de la imagen"
  class="w-full h-auto max-w-full md:max-w-3/4 lg:max-w-1/2 object-cover"
>

    Explicación del código:

    1. w-full: La imagen ocupa el 100% del ancho de su contenedor.
    2. h-auto: La altura se ajusta automáticamente para mantener la proporción de la imagen.
    3. max-w-full: Limita el ancho máximo al 100% del contenedor.
    4. md:max-w-3/4: En tablets (≥ 768px), el ancho máximo es el 75% del contenedor.
    5. lg:max-w-1/2: En pantallas grandes (≥ 1024px), el ancho máximo es el 50% del contenedor.
    6. object-cover: La imagen cubre todo el espacio disponible, recortándose si es necesario.

    Ejemplo completo con contenedor:

    Si quieres que la imagen esté dentro de un contenedor y se comporte de manera responsive, puedes hacer lo siguiente:

    <div class="container mx-auto px-4">
  <img
    src="ruta/a/tu/imagen.jpg"
    alt="Descripción de la imagen"
    class="w-full h-auto max-w-full md:max-w-3/4 lg:max-w-1/2 object-cover rounded-lg shadow-lg"
  >
</div>
    • container: Limita el ancho máximo del contenedor y lo centra.
    • mx-auto: Centra el contenedor horizontalmente.
    • px-4: Añade un padding horizontal para evitar que la imagen toque los bordes en móviles.
    • rounded-lg: Añade bordes redondeados.
    • shadow-lg: Añade una sombra para mejorar el diseño.

    Alternativa: Usar srcset para imágenes responsive (HTML nativo)

    Si quieres optimizar el rendimiento cargando diferentes versiones de la imagen según el tamaño de la pantalla, puedes usar el atributo srcset junto con Tailwind:

    <img
  src="ruta/a/tu/imagen-small.jpg"
  srcset="
    ruta/a/tu/imagen-small.jpg 480w,
    ruta/a/tu/imagen-medium.jpg 800w,
    ruta/a/tu/imagen-large.jpg 1200w
  "
  sizes="(max-width: 640px) 100vw, (max-width: 1024px) 75vw, 50vw"
  alt="Descripción de la imagen"
  class="w-full h-auto object-cover rounded-lg shadow-lg"
>
    • srcset: Define diferentes versiones de la imagen para diferentes tamaños de pantalla.
    • sizes: Indica cómo se debe escalar la imagen en diferentes breakpoints.

    Resumen:

    • Usa w-full y h-auto para que la imagen sea responsive.
    • Ajusta el tamaño máximo con max-w-*.
    • Usa object-cover o object-contain para controlar cómo se ajusta la imagen.
    • Aplica clases responsivas (md:, lg:) para ajustar el comportamiento en diferentes dispositivos.

    Este método garantiza que tu imagen se vea bien en todos los dispositivos sin distorsionarse ni perder calidad. ¡Espero que te sea útil! 😊

  • Publicado en

    Sí, existen varias herramientas en Linux que permiten hacer copias de seguridad al estilo de Git, donde se realiza una copia completa inicial y luego se gestionan cambios incrementales (diferenciales). Aquí te presento algunas opciones populares:

    1. BorgBackup

    • Descripción: BorgBackup es una herramienta de copia de seguridad que permite realizar copias completas iniciales y luego gestionar copias incrementales. Además, soporta compresión y encriptación.
    • Características:
      • Deduplicación de datos.
      • Compresión y encriptación.
      • Soporte para copias incrementales.
      • Fácil de usar y configurar.
    • Instalación: bash sudo apt-get install borgbackup # En Debian/Ubuntu sudo dnf install borgbackup # En Fedora
    • Uso básico: bash borg init /ruta/al/repositorio borg create /ruta/al/repositorio::nombre_de_la_copia /ruta/a/respaldar

    2. Restic

    • Descripción: Restic es una herramienta moderna de copias de seguridad que también utiliza deduplicación y soporta copias incrementales. Es fácil de usar y tiene soporte para varios backends (local, SFTP, AWS S3, etc.).
    • Características:
      • Deduplicación.
      • Encriptación.
      • Soporte para múltiples backends.
      • Copias incrementales.
    • Instalación: bash sudo apt-get install restic # En Debian/Ubuntu sudo dnf install restic # En Fedora
    • Uso básico: bash restic init --repo /ruta/al/repositorio restic backup --repo /ruta/al/repositorio /ruta/a/respaldar

    3. rsnapshot

    • Descripción: rsnapshot es una herramienta de copias de seguridad basada en rsync que permite realizar copias completas e incrementales. Es muy eficiente en el uso del espacio en disco.
    • Características:
      • Basado en rsync.
      • Copias completas e incrementales.
      • Fácil de configurar.
    • Instalación: bash sudo apt-get install rsnapshot # En Debian/Ubuntu sudo dnf install rsnapshot # En Fedora
    • Uso básico: bash rsnapshot configtest # Verificar la configuración rsnapshot hourly # Realizar una copia de seguridad

    4. Timeshift

    • Descripción: Timeshift es una herramienta diseñada principalmente para realizar copias de seguridad del sistema, pero también puede ser utilizada para respaldar directorios específicos. Utiliza rsync y soporta copias incrementales.
    • Características:
      • Enfocado en copias de seguridad del sistema.
      • Soporte para copias incrementales.
      • Interfaz gráfica y de línea de comandos.
    • Instalación: bash sudo apt-get install timeshift # En Debian/Ubuntu sudo dnf install timeshift # En Fedora
    • Uso básico: bash timeshift --create --comments "Copia inicial" --tags D

    5. Duplicati

    • Descripción: Duplicati es una herramienta de copias de seguridad que soporta copias incrementales y encriptación. Puede respaldar a varios destinos, incluyendo servicios en la nube.
    • Características:
      • Soporte para copias incrementales.
      • Encriptación.
      • Interfaz gráfica y de línea de comandos.
    • Instalación: bash sudo apt-get install duplicati # En Debian/Ubuntu sudo dnf install duplicati # En Fedora
    • Uso básico: bash duplicati-cli backup /ruta/a/respaldar

    6. ZBackup

    • Descripción: ZBackup es una herramienta de copias de seguridad basada en deduplicación que permite realizar copias completas e incrementales. Es eficiente en el uso del espacio y soporta compresión.
    • Características:
      • Deduplicación.
      • Compresión.
      • Soporte para copias incrementales.
    • Instalación: bash sudo apt-get install zbackup # En Debian/Ubuntu sudo dnf install zbackup # En Fedora
    • Uso básico: bash zbackup init /ruta/al/repositorio zbackup backup /ruta/al/repositorio /ruta/a/respaldar

    Conclusión

    Cada una de estas herramientas tiene sus propias ventajas y características, por lo que la elección dependerá de tus necesidades específicas. Si buscas algo simple y eficiente, BorgBackup o Restic son excelentes opciones. Si prefieres algo más enfocado en el sistema, Timeshift es una buena alternativa. Para una solución más gráfica, Duplicati puede ser la mejor opción.

    Las copias de seguridad incrementales y diferenciales son dos enfoques comunes para realizar respaldos de datos de manera eficiente, especialmente cuando se quiere ahorrar espacio y tiempo. Aquí te explico las diferencias clave entre ambas:

    Copia de seguridad incremental

    • Cómo funciona:

      • Después de una copia completa inicial, solo se respaldan los archivos que han cambiado desde la última copia de seguridad (ya sea completa o incremental).
      • Cada copia incremental depende de la copia anterior para restaurar los datos completos.

    • Ventajas:

      • Ahorro de espacio: Solo se almacenan los cambios desde la última copia, lo que reduce significativamente el tamaño de cada respaldo.
      • Velocidad: Las copias son más rápidas porque solo se procesan los archivos modificados.

    • Desventajas:

      • Restauración más compleja: Para restaurar los datos, es necesario tener la copia completa inicial y todas las copias incrementales posteriores. Si falta alguna, la restauración puede fallar.
      • Fragilidad: Si una copia incremental se corrompe, puede afectar la capacidad de restaurar datos posteriores.

    • Ejemplo:

      • Día 1: Copia completa (100 GB).
      • Día 2: Copia incremental (5 GB de cambios desde el Día 1).
      • Día 3: Copia incremental (3 GB de cambios desde el Día 2).
      • Para restaurar al Día 3, necesitas la copia completa del Día 1 y las incrementales del Día 2 y Día 3.

    Copia de seguridad diferencial

    • Cómo funciona:

      • Después de una copia completa inicial, se respaldan todos los archivos que han cambiado desde la última copia completa.
      • Cada copia diferencial contiene todos los cambios acumulados desde la última copia completa, no solo desde la última copia diferencial.

    • Ventajas:

      • Restauración más sencilla: Solo necesitas la copia completa inicial y la última copia diferencial para restaurar los datos.
      • Menos frágil: Si una copia diferencial se corrompe, no afecta a las copias anteriores.

    • Desventajas:

      • Mayor uso de espacio: Cada copia diferencial es más grande que una incremental, ya que incluye todos los cambios desde la última copia completa.
      • Más lento: A medida que pasa el tiempo, las copias diferenciales pueden volverse más grandes y tardar más en realizarse.

    • Ejemplo:

      • Día 1: Copia completa (100 GB).
      • Día 2: Copia diferencial (5 GB de cambios desde el Día 1).
      • Día 3: Copia diferencial (8 GB de cambios acumulados desde el Día 1).
      • Para restaurar al Día 3, solo necesitas la copia completa del Día 1 y la diferencial del Día 3.

    Resumen de diferencias

    Característica Copia incremental Copia diferencial
    Base de referencia Cambios desde la última copia (completa o incremental). Cambios desde la última copia completa.
    Tamaño de copia Más pequeño (solo cambios recientes). Más grande (cambios acumulados).
    Restauración Requiere copia completa + todas las incrementales. Requiere copia completa + última diferencial.
    Velocidad de copia Más rápida (solo cambios recientes). Más lenta (cambios acumulados).
    Robustez Más frágil (depende de todas las copias). Menos frágil (depende de la última).

    ¿Cuál elegir?

    • Incremental: Ideal si tienes limitaciones de espacio y tiempo, y no te importa la complejidad de la restauración.
    • Diferencial: Recomendado si prefieres una restauración más sencilla y no te preocupa el mayor uso de espacio.

    Ambas estrategias son útiles, y la elección depende de tus necesidades específicas, como la frecuencia de las copias, el espacio disponible y la importancia de la facilidad de restauración.

  • Publicado en

    Decodificacion por shell de Texto en base64

    echo "Base64Text' | base64 --decode

    Util para el fichero de sitemanager.xml de Filezilla

    grep -E 'Host|User|Pass' sitemanager.xml

    Y pasar una macro en neovim para formatearla y un subshell para su decodificacion.

  • Publicado en

    Instalación de Git

    Primero, instala Git en tu sistema openSUSE Tumbleweed. Ejecuta los siguientes comandos como usuario root:
    Es posibele que no haga falta instalar el repositorio, si ya se ha configurado previamente el servidor con OpenSUSE.
    zypper addrepo https://download.opensuse.org/repositories/devel:tools:scm/openSUSE_Tumbleweed/devel:tools:scm.repo zypper refresh zypper install git

    Configuración del servidor

    sudo adduser git
su git

    Configurar el directorio SSH para el usuario git:

    cd
mkdir .ssh && chmod 700 .ssh
touch .ssh/authorized_keys && chmod 600 .ssh/authorized_keys

    Creación de un repositorio

    Crea un directorio para almacenar los repositorios:

    sudo mkdir /opt/git
sudo chown git:git /opt/git

    Crea un repositorio vacío:

    cd /opt/git
mkdir proyecto.git
cd proyecto.git
git init --bare

    Configuración de acceso SSH

    Para permitir que los desarrolladores accedan al repositorio, hay que agregar sus claves públicas SSH al archivo authorized_keys del usuario git:

    cat /tmp/id_rsa.desarrollador1.pub >> ~/.ssh/authorized_keys
cat /tmp/id_rsa.desarrollador2.pub >> ~/.ssh/authorized_keys

    Restricción de acceso (opcional)

    Para mayor seguridad, puedes limitar el acceso del usuario git solo a operaciones de Git: Verificar si git-shell está disponible:

    cat /etc/shells

    Si no está listado, agrégarlo:

    which git-shell
sudo vim /etc/shells

    Añadir la ruta completa de git-shell al final del archivo. Cambia el shell del usuario git:

    sudo chsh git

    Ingresar la ruta de git-shell (generalmente /usr/bin/git-shell). Uso del servidor Los desarrolladores pueden ahora clonar el repositorio usando:

    git clone git@tu_servidor:/opt/git/proyecto.git

    Y pueden enviar cambios al repositorio:

    git push origin master
  • Publicado en

    Para crear un CRUD (Crear, Leer, Actualizar y Eliminar) de usuarios utilizando Node.js con Express como backend y MariaDB como base de datos, siguiendo tu configuración con Apache2 y un dominio virtual hay que seguir estos pasos:

    Configuración inicial
    Primero, asegurarse de tener instalados Node.js, npm y MariaDB en el sistema. Luego, crea un nuevo proyecto e instalar las dependencias necesarias:

    mkdir crud-usuarios
cd crud-usuarios
npm init -y
npm install express mysql2 body-parser

    Estructura del proyecto
    Crear la siguiente estructura de archivos:

    crud-usuarios/
    ├── app.js
    ├── config/
    │ └────── db.js
    └── routes/
    └────── users.js

    Configuración de la base de datos
    En el archivo config/db.js, configura la conexión a MariaDB:
    [ config/db.js ]

    const mysql = require('mysql2');

const connection = mysql.createConnection({
  host: 'localhost',
  user: 'tu_usuario',
  password: 'tu_contraseña',
  database: 'tu_base_de_datos'
});

connection.connect(error => {
  if (error) throw error;
  console.log('Conexión exitosa a la base de datos.');
});

module.exports = connection;

    Configuración del servidor Express
    En el archivo app.js, configura el servidor Express:

    [ app.js ]

    const express = require('express');
const bodyParser = require('body-parser');
const usersRoutes = require('./routes/users');

const app = express();

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

app.use('/api/users', usersRoutes);

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Servidor corriendo en el puerto ${PORT}`);
});

    Implementación de las rutas CRUD
    En el archivo routes/users.js, implementa las rutas para el CRUD:
    [ routes/users.js ]

    const express = require('express');
const router = express.Router();
const db = require('../config/db');

// Crear un usuario
router.post('/', (req, res) => {
  const { user, username } = req.body;
  const query = 'INSERT INTO users (user, username) VALUES (?, ?)';

  db.query(query, [user, username], (error, results) => {
    if (error) {
      return res.status(500).json({ error: error.message });
    }
    res.status(201).json({ id: results.insertId, user, username });
  });
});

// Obtener todos los usuarios
router.get('/', (req, res) => {
  const query = 'SELECT * FROM users';

  db.query(query, (error, results) => {
    if (error) {
      return res.status(500).json({ error: error.message });
    }
    res.json(results);
  });
});

// Obtener un usuario por ID
router.get('/:id', (req, res) => {
  const query = 'SELECT * FROM users WHERE id = ?';

  db.query(query, [req.params.id], (error, results) => {
    if (error) {
      return res.status(500).json({ error: error.message });
    }
    if (results.length === 0) {
      return res.status(404).json({ message: 'Usuario no encontrado' });
    }
    res.json(results[0]);
  });
});

// Actualizar un usuario
router.put('/:id', (req, res) => {
  const { user, username } = req.body;
  const query = 'UPDATE users SET user = ?, username = ? WHERE id = ?';

  db.query(query, [user, username, req.params.id], (error, results) => {
    if (error) {
      return res.status(500).json({ error: error.message });
    }
    if (results.affectedRows === 0) {
      return res.status(404).json({ message: 'Usuario no encontrado' });
    }
    res.json({ id: req.params.id, user, username });
  });
});

// Eliminar un usuario
router.delete('/:id', (req, res) => {
  const query = 'DELETE FROM users WHERE id = ?';

  db.query(query, [req.params.id], (error, results) => {
    if (error) {
      return res.status(500).json({ error: error.message });
    }
    if (results.affectedRows === 0) {
      return res.status(404).json({ message: 'Usuario no encontrado' });
    }
    res.json({ message: 'Usuario eliminado correctamente' });
  });
});

module.exports = router;

    Configuración de Apache2 como proxy inverso
    Para que Apache2 funcione como proxy inverso para la aplicación Node.js, se necesita configurar un virtual host. Editar el archivo de configuración del dominio virtual:

    sudo nvim  /etc/apache2/sites-available/subdomain.dominio.net.conf

    Añadir la siguiente configuración:

    <VirtualHost *:80>
    ServerName subdomain.dominio.net
    ProxyPreserveHost On
    ProxyPass / http://localhost:3000/
    ProxyPassReverse / http://localhost:3000/
    ErrorLog ${APACHE_LOG_DIR}/subdomain.dominio.net-error.log
    CustomLog ${APACHE_LOG_DIR}/subdomain.dominio.net-access.log combined
</VirtualHost>

    Habilitar el módulo proxy de Apache2 y reiniciar el servicio:

    sudo a2enmod proxy proxy_http
sudo systemctl restart apache2

    Uso del CRUD
    Ahora puedes usar el CRUD a través de tu dominio virtual:

    • Crear un usuario: POST http://subdomain.dominio.net/api/users
    • Obtener todos los usuarios: GET http://subdomain.dominio.net/api/users
    • Obtener un usuario por ID: GET http://subdomain.dominio.net/api/users/:id
    • Actualizar un usuario: PUT http://subdomain.dominio.net/api/users/:id
    • Eliminar un usuario: DELETE http://subdomain.dominio.net/api/users/:id

    Iniciar la aplicación Node.js con:

    node app.js

    Este CRUD te permitirá gestionar los usuarios en tu base de datos MariaDB a través de una API RESTful, accesible desde tu dominio virtual http://subdomain.dominio.tinux.net

  • Publicado en

    Actualizacion de Nextcloud

    #!/bin/zsh  

    # Definir la URL de la página de descargas de Nextcloud  

URL="https://nextcloud.com/install/#install-clients"

# Obtener el enlace de descarga de la última versión AppImage
DOWNLOAD_URL=$(curl -s $URL | grep -oP 'https://.*?Nextcloud-.*?-x86_64\.AppImage' | head -n 1)

if [ -z "$DOWNLOAD_URL" ]; then
    echo "No se pudo encontrar el enlace de descarga de la AppImage."
    exit 1
fi

# Descargar la AppImage
echo "Descargando la última versión de Nextcloud..."
wget -q "$DOWNLOAD_URL" -O /tmp/nextcloud.AppImage

if [ $? -ne 0 ]; then
    echo "Error al descargar la AppImage."
    exit 1
fi

    # Hacer ejecutable la AppImage

chmod +x /tmp/nextcloud.AppImage

# Detener el proceso de Nextcloud si está en ejecución
pkill -f nextcloud

    # Reemplazar el archivo existente

echo "Reemplazando el archivo existente..."
sudo mv /tmp/nextcloud.AppImage /usr/bin/nextcloud

if [ $? -ne 0 ]; then
    echo "Error al reemplazar el archivo. Asegúrate de tener permisos de superusuario."
    exit 1
fi

echo "Actualización completada con éxito."
  • Publicado en

    Al analizar la página web proporcionada, se pueden detectar algunos errores y áreas de mejora en su estructura HTML:

    Errores de estructura

    1. Falta de estructura HTML básica: No se observa la estructura HTML completa con las etiquetas <!DOCTYPE html>, <html>, <head> y <body>[1]. Esto es fundamental para una correcta interpretación por parte de los navegadores.

    2. Ausencia de metadatos: No se incluyen etiquetas meta importantes como <meta charset="UTF-8"> para la codificación de caracteres, ni <meta name="viewport"> para la adaptación a dispositivos móviles[1].

    3. Falta de título: No se encuentra la etiqueta <title> que debería estar dentro del <head> para definir el título de la página[1].

    Problemas de accesibilidad y semántica

    1. Uso incorrecto de encabezados: El texto "YOUR HOUSE UNDER THE SUN" debería ser un encabezado principal <h1> en lugar de texto plano[1].

    2. Falta de etiquetas semánticas: No se utilizan etiquetas como <header>, <nav>, <main>, <section> o <footer> para estructurar el contenido de manera semántica[1].

    3. Ausencia de atributos alt: Las imágenes de las propiedades carecen de atributos alt para describir su contenido, lo cual es esencial para la accesibilidad[1].

    Errores de contenido

    1. Inconsistencia en el idioma: El título está en inglés ("YOUR HOUSE UNDER THE SUN"), mientras que el resto del contenido está en español. Se debería mantener un idioma consistente o utilizar etiquetas lang apropiadas[1].

    2. Falta de formulario: El campo de búsqueda "Buscar" no está dentro de un elemento <form>, lo que podría afectar su funcionalidad[1].

    3. Información de contacto no estructurada: Los datos de contacto deberían estar dentro de una estructura más semántica, como una lista o utilizando la etiqueta <address>[1].

    Corregir estos errores mejoraría significativamente la estructura, accesibilidad y optimización para motores de búsqueda de la página web.

    Citations: [1] https://ppl-ai-file-upload.s3.amazonaws.com/web/direct-files/10537800/a394b72b-738b-4ab9-b0c8-4fc08fc4d20c/paste.txt