Blog Tinux Net

Trabajos Frontens, Backed y Servidores Linux

En este Blog se trabajara sobre el trabajo diario de Desarrollo con Servidores y Web Developer
  • 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

  • Publicado en

    Creado dos archivos, el script en s, y el archivo de exclusion

    File rsync-remote.zsh :

    rsync -avr --exclude-from='.exclude.rsync' --exclude  ~/NombreCliente/httpdocs-dev/ nombre_usuario@dominio.io:/ruta/absoluta/del/httpdocs-dev
    

    Recomendable es que se ponga la clave publica de .ssh en el directorio de know_host para que no se tenga que preguntar por contraseña File .exclude.rsync :

    .exclude.rsync
    node_modules/
    src/
    software/
    package-lock.json
    package.json
    *nextcloudsync.log
    *.db
    *.dba
    *.db-wal
    *sync-exclude.lst
    *db-shm
    

    Principalmente son los archivos que no son necesario o bien tendrían un problema de seguridad.

  • Publicado en

    Tabla de tamaños imagenes

    Tipo de Imagen Desktop Mobile Ratio
    Background 2560 x 1400 pixels 360 x 640 pixels 16:9
    Principal 1280 x 720 pixels 360 x 200 pixels 16:9
    Banner 1200 x 400 pixels 360 x 120 pixels 3:1
    Blog 1200 x 800 pixels 360 x 240 pixels 3:2
    Logo (rectangle) 400 x 100 pixels 160 x 40 pixels 4:1
    Logo (square) 100 x 100 pixels 60 x 60 pixels 1:1
    Favicon 16 x 16 pixels 16 x 16 pixels 1:1
    Íconos redes 32 x 32 pixels 48 x 48 pixels 1:1
    Lightbox (full screen) 1920 x 1080 pixels 360 x 640 pixels 16:9
    Thumbnail 300 x 300 pixels 90 x 90 pixels 1:1