Montaje Automático de Discos con Autofs en Debian/Ubuntu: Guía Completa

Introducción

Autofs es un servicio de Linux que permite montar y desmontar sistemas de archivos de forma automática según la demanda. Esto facilita la administración de dispositivos externos (como discos USB) o directorios remotos (como NFS o Samba), ya que los sistemas de archivos se montan solo cuando se acceden, ahorrando recursos del sistema y simplificando la configuración para el usuario.

1. Instalación de Autofs en Debian/Ubuntu

Antes de configurar autofs, primero necesitamos instalarlo en nuestro sistema. Los pasos son sencillos para distribuciones basadas en Debian o Ubuntu:

1. Actualizar la lista de paquetes:
   Es una buena práctica asegurarse de que tu lista de paquetes esté actualizada antes de instalar nuevo software.

   sudo apt update

2. Instalar Autofs:
   Usa el siguiente comando para instalar el paquete autofs:

   sudo apt install autofs

3. Verificar el estado del servicio (opcional pero recomendado):
   Una vez instalado, puedes verificar si el servicio autofs se está ejecutando correctamente:

   sudo systemctl status autofs

   Deberías ver que está “active (running)”. Si no está activo por alguna razón, puedes iniciarlo con sudo systemctl start autofs.

4. Habilitar el servicio para que inicie automáticamente (opcional pero recomendado):
   Para que autofs se inicie cada vez que el sistema arranca, ejecuta:

   sudo systemctl enable autofs

Con autofs instalado y en ejecución, ya podemos proceder a su configuración para montar dispositivos automáticamente.

2. Configurar autofs para montar un disco usando su UUID

Usar el UUID (Universally Unique Identifier) es la forma más robusta de identificar un disco o partición, ya que no cambia aunque conectes el disco a un puerto USB diferente o cambie su designación de dispositivo (como /dev/sdb1, /dev/sdc1, etc.).

1. Identificar el dispositivo de disco (opcional pero útil)
   Antes de obtener el UUID, puede ser útil identificar el nombre del dispositivo de tu disco (como /dev/sdb1, /dev/sdc1, etc.), especialmente si tienes varios conectados o si acabas de insertar una unidad USB. Puedes usar el comando lsblk:

   lsblk -fp

   Este comando listará tus dispositivos de bloque con sus rutas completas y, si están montados, sus puntos de montaje. Busca el que corresponda a tu disco (por tamaño, etiqueta o si es el único no montado recientemente conectado). Anota su nombre (ej. /dev/sdb1). Esto te ayudará a localizarlo más fácilmente en la salida de `blkid`.

2. Obtener el UUID del disco o partición
   Para encontrar el UUID de tu disco o partición, conecta el dispositivo y utiliza el siguiente comando:

   sudo blkid

   Busca la línea que corresponde a tu dispositivo (el que identificaste con `lsblk`, por ejemplo, /dev/sdb1). Verás algo como:

   /dev/sdb1: LABEL="MiDiscoExterno" UUID="4d90510a-2695-4150-9021-2b639c252fdb" TYPE="ext4" PARTUUID="..."

   Copia el valor de UUID (en el ejemplo, 4d90510a-2695-4150-9021-2b639c252fdb).

3. Editar el archivo de configuración principal de autofs (mapa maestro)
   Este archivo le dice a autofs dónde buscar las configuraciones específicas de montaje. Abre el archivo /etc/auto.master con tu editor preferido (nano, vim, etc.):

   sudo nano /etc/auto.master

   Agrega la siguiente línea al final del archivo. Puedes comentar otras líneas si no las necesitas añadiendo un # al principio:

   /media/autofs /etc/auto.uuid --timeout=60 --ghost

   Explicación de esta línea:

   • /media/autofs: Es el directorio base donde se crearán los subdirectorios para los montajes automáticos definidos en el archivo de mapa. Puedes elegir otra ruta si lo prefieres.
   • /etc/auto.uuid: Es el archivo de mapa que contendrá las reglas específicas para montar los dispositivos. Puedes nombrarlo como quieras (ej. auto.discos), pero asegúrate de que el nombre coincida en el siguiente paso.
   • --timeout=60: Especifica que el sistema de archivos se desmontará automáticamente después de 60 segundos de inactividad.
   • --ghost: Asegura que los directorios de montaje (definidos en el archivo de mapa) sean visibles incluso cuando el dispositivo no esté montado. Esto es útil para la navegación.

   Guarda y cierra el archivo (Ctrl+O, Enter, Ctrl+X en nano).

4. Crear y editar el archivo de mapa para autofs
   Ahora creamos el archivo que especificamos en auto.master (en nuestro ejemplo, /etc/auto.uuid):

   sudo nano /etc/auto.uuid

   Agrega una línea por cada dispositivo que quieras montar automáticamente. Usando el UUID del ejemplo anterior:

   externo -fstype=ext4    :UUID=4d90510a-2695-4150-9021-2b639c252fdb

   Explicación de esta línea:

   • externo: Este será el nombre del subdirectorio que se creará dentro de /media/autofs. Así, el disco se montará en /media/autofs/externo. Puedes elegir el nombre que quieras (ej. “backup_usb”, “fotos_disco”).
   • -fstype=ext4: Especifica el tipo de sistema de archivos del disco.
     • Cámbialo si tu disco usa otro formato (ej. ntfs-3g para NTFS, vfat para FAT32, exfat para exFAT).
     • También puedes usar -fstype=auto para que autofs intente detectar automáticamente el tipo de sistema de archivos.
     • Si necesitas opciones de montaje específicas (como solo lectura ro, o lectura/escritura rw que suele ser el predeterminado), puedes añadirlas separadas por comas después del tipo de sistema de archivos (ej. -fstype=ext4,ro).
   • :UUID=4d90510a-2695-4150-9021-2b639c252fdb: Indica que se debe montar el dispositivo con el UUID especificado. Asegúrate de reemplazarlo con el UUID real de tu disco. El colon (:) antes de UUID es importante.

   Guarda y cierra el archivo.

5. Crear el directorio base de montaje (si no existe)
   Aunque la opción --ghost puede crear los subdirectorios, es una buena práctica asegurarse de que el directorio base (/media/autofs en nuestro ejemplo) exista.

   sudo mkdir -p /media/autofs

   Nota: Si no usaste --ghost, el subdirectorio (ej. /media/autofs/externo) no será visible hasta que intentes acceder a él y el montaje ocurra. Con --ghost, sí será visible.

6. Reiniciar autofs para aplicar los cambios
   Para que autofs lea la nueva configuración, reinicia el servicio:

   sudo systemctl restart autofs

   Si hay errores en tus archivos de configuración, este comando podría fallar. Puedes revisar los logs con journalctl -u autofs.service o sudo systemctl status autofs para obtener más detalles.

3. ¿Cómo probar si funciona?

Para verificar que el montaje automático se realiza correctamente, primero intenta listar el contenido del directorio de montaje que configuraste:

ls /media/autofs/externo

La primera vez que accedas a esta ruta (si el disco está conectado y la configuración es correcta), autofs montará automáticamente el dispositivo. Los accesos subsiguientes serán directos hasta que el timeout expire y se desmonte.

Una vez que hayas accedido al directorio (lo que debería haber provocado el montaje), puedes verificarlo con varios comandos:

• Con lsblk: Este comando es muy útil para ver cómo están montados tus dispositivos de bloque.

  lsblk

  O para más detalle, incluyendo el tipo de sistema de archivos:

  lsblk -f

  Busca tu dispositivo (ej. sdb1) en la lista. Si autofs ha funcionado, deberías ver /media/autofs/externo (o la ruta que hayas configurado) en la columna MOUNTPOINT (o PUNTO MONTAJE) correspondiente a tu dispositivo.

• Con df -h: Este comando muestra el uso del espacio en disco de los sistemas de archivos montados.

  df -h

  Deberías ver una entrada para /media/autofs/externo.

• Con mount: Puedes filtrar la salida para buscar tu montaje específico.

  mount | grep autofs

  O específicamente para tu dispositivo:

  mount | grep /media/autofs/externo

Consideraciones Adicionales

• Tipos de Archivos: Asegúrate de que el fstype en tu archivo de mapa (ej. /etc/auto.uuid) coincida con el sistema de archivos real de tu partición (ext4, ntfs, exfat, vfat, etc.) o usa auto. Si es NTFS, puede que necesites instalar el paquete ntfs-3g y usar fstype=ntfs-3g. Para exFAT, instala exfat-fuse y exfat-utils y usa fstype=exfat.
• Múltiples Dispositivos: Puedes añadir múltiples líneas a tu archivo /etc/auto.uuid (o como lo hayas llamado), una por cada dispositivo que quieras automontar, cada uno con su propio nombre de subdirectorio y UUID.
• Solución de Problemas: Si algo no funciona, revisa los mensajes del sistema con sudo journalctl -fu autofs.service mientras intentas acceder al punto de montaje. Esto suele dar pistas sobre errores de sintaxis en los archivos de configuración o problemas con el dispositivo.

El cargo Autofs con UUID: Automatiza el montaje de discos en Linux apareció primero en HirCoir.

Antes de comenzar el tutorial es importante tener descargada la Imagen de su Orange Pi/Raspberry Pi que desean editar. imagen-linux.img será la imagen de Linux de su placa a editar y tmp_mount será la carpeta temporal donde se montará la raíz de su imagen.

Antes de intentar montar una imagen de disco de Orange Pi o Raspberry Pi, es importante conocer el tipo de sistema de archivos que utiliza la imagen. Esto se puede hacer con el comando file, como se mencionó anteriormente:

sudo file imagen-linux.img 
imagen-linux.img: DOS/MBR boot sector; partition 1 : ID=0x83, start-CHS (0x20,0,1), end-CHS (0x3ff,3,32), startsector 65536, 4128768 sectors

Identifica las particiones en la imagen de disco: El siguiente paso es identificar las particiones dentro de la imagen de disco. Puedes hacer esto utilizando herramientas como fdisk o parted. Para ver una lista de particiones dentro de la imagen de disco, ejecuta el siguiente comando:
sudo fdisk -l tu-imagen-linux.img
Esto debería producir una salida similar a esta:

sudo fdisk -l imagen-linux.img 
Disk imagen-linux.img: 2 GiB, 2147483648 bytes, 4194304 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xe34d5f84

Device            Boot Start     End Sectors Size Id Type
imagen-linux.img1      65536 4194303 4128768   2G 83 Linux

Aquí podemos ver que la imagen de disco contiene una partición, la partición 1, que comienza en el sector 65536 y tiene un tamaño de 2 GB. Toma nota del número de partición y el sistema de archivos correspondiente.

Paso 1: Montando la Imagen Raspbian: Comencemos montando la imagen Raspbian de tu Orange Pi. Utiliza los siguientes comandos en tu terminal:

sudo mkdir tmp_mount
sudo mount -o loop,offset=$((65536 * 512)) imagen-linux.img tmp_mount

root@Linux:/home/hir/Escritorio# mkdir tmp_mount
root@Linux:/home/hir/Escritorio# sudo mount -o loop,offset=$((65536 * 512)) imagen-linux.img tmp_mount
root@Linux:/home/hir/Escritorio# ls tmp_mount/
bin  boot  dev  etc  home  lib  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

Paso 2: Montando Particiones Necesarias: Asegurémonos de tener acceso a las particiones necesarias utilizando los siguientes comandos:

sudo mount -t proc /proc tmp_mount/proc
sudo mount -t sysfs /sys tmp_mount/sys
sudo mount -o bind /dev tmp_mount/dev

Paso 3: Instalando y Configurando Qemu: Para ejecutar chroot, necesitamos Qemu. Instálemoslo y copiemos el binario necesario:

sudo apt-get install qemu-user-static -y
sudo cp /usr/bin/qemu-aarch64-static tmp_mount/usr/bin/

Paso 4: Ingresando al Entorno Chroot: Ahora, ingresaremos al entorno chroot con el siguiente comando:

sudo chroot tmp_mount /usr/bin/qemu-aarch64-static /bin/bash

root@Linux:/home/hir/Escritorio# sudo chroot tmp_mount /usr/bin/qemu-aarch64-static /bin/bash
┌──(root㉿Linux)-[/]
└─#

Paso 5: Personalizando tu Orange Pi: Estás dentro del entorno chroot, ¡es hora de personalizar tu Orange Pi! Instala las herramientas que desees, como cockpit, y neofetch.

┌──(root㉿Linux)-[/]
└─# sudo apt-get update
┌──(root㉿Linux)-[/]
└─# sudo apt-get install -y cockpit neofetch

Haz todas las personalizaciones necesarias según tus preferencias. Al terminar puedes salir del chroot con exit.

┌──(root㉿Linux)-[/]
└─# exit

Paso 6: Desmontando Particiones: Una vez que hayas terminado de personalizar, desmonta las particiones para finalizar el proceso:

sudo umount tmp_mount/proc
sudo umount tmp_mount/sys
sudo umount tmp_mount/dev
sudo umount tmp_mount

¡Y eso es todo! Ahora tienes una imagen personalizada lista para tu Orange Pi. Espero que esta guía haya sido clara y útil. ¡Disfruta de tu Orange Pi personalizada!

El cargo Creando una Imagen Personalizada para Orange Pi/Raspberry Pi: Guía Paso a Paso apareció primero en HirCoir.

Requisitos:

Antes de empezar, asegúrate de tener Docker instalado en tu ordenador. Si no lo tienes instalado, puedes seguir el siguiente tutorial para instalarlo en Ubuntu/Debian: https://www.hircoir.eu.org/instalar-docker-portainer-en-ubuntu/
Si tienes un sistema operativo puedes descargarlo desde el sitio web oficial de Docker: https://www.docker.com/get-started

Paso 1: Descarga el Dockerfile

El primer paso es descargar el Dockerfile que has creado. Puedes hacerlo clonando el repositorio de GitHub donde lo has guardado:

git clone https://github.com/HirCoir/OpenAI-Whisper-Dockerfile

Reemplaza USERNAME y REPOSITORY con tu nombre de usuario y el nombre del repositorio donde has guardado el Dockerfile.

Paso 2: Crea la imagen Docker

Una vez que tengas el Dockerfile en tu ordenador, puedes crear la imagen Docker utilizando el comando docker build.

Ve al directorio donde has guardado el Dockerfile y ejecuta el siguiente comando:

docker build -t hircoir/whisper-vscode .

Este comando creará una imagen Docker con el nombre hircoir/whisper-vscode utilizando el Dockerfile que acabas de descargar. El punto al final del comando indica que el Dockerfile está en la carpeta actual.

Paso 3: Ejecuta el contenedor Docker

Una vez que se haya creado la imagen Docker, puedes ejecutar el contenedor utilizando el comando docker run.

Ejecuta el contenedor, (en Pass13133 reemplázalo por una contraseña diferente ya que es la que usarás para acceder a vscode-web)

docker run -d --name=whisper-vscode --restart=always -e PASSWORD=Pass13133 -p 8080:8080 hircoir/whisper-vscode

Este comando iniciará el contenedor Docker y lo hará accesible desde tu navegador web en http://localhost:8080. El parámetro -p 8080:8080 indica que el puerto 8080 del contenedor Docker se mapeará al puerto 8080 de tu ordenador.

Usar Whisper desde una imagen ya existente en dockerhub:

AMD64/x86_x64

docker run -d --name=whisper-vscode --restart=always -e PASSWORD=Pass13133 -p 8080:8080 hircoir/whisper-vscode:amd64

ARM64

docker run -d --name=whisper-vscode --restart=always -e PASSWORD=Pass13133 -p 8080:8080 hircoir/whisper-vscode:arm64

Paso 4: Accede a VSCode y Whisper

Abre tu navegador web y accede a http://ip-docker-server:8080. Se te pedirá que introduzcas una contraseña para iniciar sesión en VSCode. Utiliza la contraseña que estableciste al iniciar el contenedor.

Una vez que hayas iniciado sesión, verás la interfaz de VSCode. Para acceder a Whisper, escribe menu en la terminal de VSCode y presiona Enter. Esto abrirá un menú con funciones básicas de Whisper, como transcribir un archivo de audio o transcribir y traducir a un idioma diferente.

¡Eso es todo! Ahora puedes usar Whisper con VSCode en un contenedor Docker.

El cargo Instalar y usar Openai/Whisper en Docker apareció primero en HirCoir.

Instalación de MySQL

Antes de empezar, debes tener acceso a un servidor web y a un usuario con permisos para instalar software. Si estás usando un sistema operativo basado en Linux, como Ubuntu o CentOS, puedes seguir estos pasos para instalar MySQL:

1. Abre la terminal y actualiza los repositorios del sistema: sudo apt update o sudo yum update
2. Instala el servidor de MySQL: sudo apt install mysql-server o sudo yum install mysql-server
3. Inicia el servicio de MySQL: sudo systemctl start mysql o sudo service mysql start
4. Configura la seguridad de MySQL: sudo mysql_secure_installationEsta configuración incluye cambiar la contraseña del usuario root de MySQL, eliminar usuarios anónimos y deshabilitar el inicio de sesión remoto con el usuario root.
5. Verifica que MySQL esté funcionando: sudo systemctl status mysql o sudo service mysql status

Creación de usuarios y asignación de permisos

Después de instalar MySQL, puedes crear usuarios y asignarles permisos para acceder y administrar las bases de datos.

1. Inicia sesión en MySQL como el usuario root: sudo mysql -u root -p
   
2. Crea un nuevo usuario y asigna una contraseña: CREATE USER 'nombre_usuario'@'localhost' IDENTIFIED BY 'contraseña';
   
3. Crea una nueva base de datos: CREATE DATABASE nombre_base_datos;
   
4. Asigna permisos al usuario sobre la base de datos: GRANT ALL PRIVILEGES ON nombre_base_datos.* TO 'nombre_usuario'@'localhost';Con este comando, estás otorgando todos los permisos al usuario nombre_usuario para la base de datos nombre_base_datos.
   
5. Verifica los permisos asignados: SHOW GRANTS FOR 'nombre_usuario'@'localhost';

Asignación de base de datos a usuarios

Si deseas asignar una base de datos existente a un usuario, puedes seguir estos pasos:

1. Inicia sesión en MySQL como el usuario root: sudo mysql -u root -p
   
2. Asigna permisos al usuario sobre la base de datos existente: GRANT ALL PRIVILEGES ON nombre_base_datos.* TO 'nombre_usuario'@'localhost';
   
   Asegúrate de reemplazar nombre_base_datos y nombre_usuario por los nombres correspondientes.

Asignación de permisos root a un usuario

Asignar permisos de superusuario (root) a un usuario puede ser útil si necesitas que el usuario tenga acceso completo al servidor de MySQL. Sin embargo, esto también puede ser peligroso, ya que el usuario podría hacer cambios en la configuración del servidor o eliminar bases de datos importantes. Por lo tanto, es importante limitar el acceso root en MySQL y solo asignar permisos de superusuario a usuarios de confianza.

Para asignar permisos de superusuario (root) a un usuario en MySQL, sigue estos pasos:

1. Inicia sesión en MySQL como el usuario root: sudo mysql -u root -p
   
2. Crea un nuevo usuario y asigna una contraseña: CREATE USER 'nombre_usuario'@'localhost' IDENTIFIED BY 'contraseña';
3. Asigna permisos de superusuario (root) al usuario: GRANT ALL PRIVILEGES ON *.* TO 'nombre_usuario'@'localhost' WITH GRANT OPTION;Este comando otorga todos los permisos al usuario nombre_usuario en todas las bases de datos y tablas del servidor MySQL, así como el permiso GRANT OPTION, que permite al usuario otorgar permisos a otros usuarios.
   
4. Verifica los permisos asignados: SHOW GRANTS FOR 'nombre_usuario'@'localhost';Este comando mostrará todos los permisos que se han otorgado al usuario nombre_usuario en el servidor MySQL.

Por qué es importante limitar el acceso root en MySQL

Limitar el acceso root en MySQL es importante porque el usuario root tiene acceso completo al servidor de MySQL y puede hacer cambios que podrían ser perjudiciales para la seguridad y el rendimiento del servidor. Si un usuario malintencionado obtiene acceso root, podría modificar las bases de datos, robar información confidencial o instalar software malicioso.

Por lo tanto, se recomienda crear usuarios con permisos limitados y solo otorgar permisos de superusuario (root) a usuarios de confianza que necesitan acceso completo al servidor de MySQL. También se recomienda proteger el usuario root con una contraseña segura y deshabilitar el acceso remoto al usuario root para evitar posibles vulnerabilidades de seguridad.

Eliminación de bases de datos

Si deseas eliminar una base de datos existente, puedes seguir estos pasos:

1. Inicia sesión en MySQL como el usuario root: sudo mysql -u root -p
2. Elimina la base de datos: DROP DATABASE nombre_base_datos;Asegúrate de reemplazar nombre_base_datos por el nombre de la base de datos que deseas eliminar.

¡Eso es todo! Espero que este tutorial te haya sido útil para aprender cómo instalar MySQL, crear usuarios, asignar permisos y eliminar bases de datos.

El cargo Cómo usar MySQL apareció primero en HirCoir.

¿Qué es Supervisor?

Supervisor es un sistema cliente/servidor que permite supervisar y controlar procesos en segundo plano en sistemas operativos basados en Unix. Con Supervisor, puedes iniciar, detener y reiniciar procesos automáticamente, y recibir alertas si alguno de ellos falla.

Instalación de Supervisor

Para instalar Supervisor en tu servidor, sigue estos sencillos pasos:

1: Abre una terminal en tu servidor e ingresa el siguiente comando para actualizar la lista de paquetes disponibles:
sudo apt-get update

2: Luego, ingresa el siguiente comando para instalar Supervisor:
sudo apt-get install supervisor

3: Una vez que la instalación haya finalizado, inicia el servicio Supervisor con el siguiente comando:
sudo service supervisor start

¡Listo! Ahora, Supervisor está instalado y listo para ser configurado.

Configuración de Supervisor

Supervisor se configura a través de un archivo llamado supervisord.conf, que se encuentra en la carpeta /etc/supervisor. Para configurar Supervisor, sigue estos pasos:
1: Abre el archivo supervisord.conf con el siguiente comando:
sudo nano /etc/supervisor/supervisord.conf

2: Dentro del archivo, puedes definir los programas que deseas supervisar. Por ejemplo, puedes agregar lo siguiente al final del archivo para supervisar un programa llamado my_program.py:

[program:my_program]
command=/path/to/my_program.sh
autostart=true
autorestart=true
stderr_logfile=/var/log/my_program.err.log
stdout_logfile=/var/log/my_program.out.log

En este ejemplo, command es la ruta del programa que deseas supervisar, autostart indica si el programa debe iniciarse automáticamente cuando Supervisor se inicia, autorestart indica si el programa debe reiniciarse automáticamente si falla, y stderr_logfile y stdout_logfile son las rutas de los archivos de registro para errores y salida estándar, respectivamente.

Guarda el archivo y reinicia Supervisor con el siguiente comando:
sudo service supervisor restart

¡Listo! Ahora, Supervisor supervisará el programa que has definido.

Ejemplos de uso de Supervisor

A continuación, se presentan siete ejemplos prácticos de cómo usar Supervisor para administrar procesos en segundo plano en tu servidor:

1: Ejecución de un script de Python

Si tienes un script de Python que deseas ejecutar en segundo plano, puedes supervisarlo con Supervisor de la siguiente manera:

[program:my_script]
command=/path/to/my_script.py
autostart=true
autorestart=true
stderr_logfile=/var/log/my_script.err.log
stdout_logfile=/var/log/my_script.out.log

2: Ejecución de un servidor de Node.js

Si tienes un servidor de Node.js que deseas supervisar con Supervisor, puedes hacerlo de la siguiente manera:

[program:my_server]
command=/path/to/node /path/to/my_server.js
autostart=true
autorestart=true
stderr_logfile=/var/log/my_server.err.log
stdout_logfile=/var/log/my_server.out.log

En este ejemplo, command es la ruta del ejecutable de Node.js y la ruta del archivo del servidor de Node.js que deseas ejecutar.

3: Ejecución de una cola de trabajos con Celery

Si estás usando Celery para administrar una cola de trabajos en tu servidor, puedes supervisar los trabajos de la siguiente manera:

[program:celery]
command=/path/to/celery worker -A myapp.tasks --loglevel=INFO
directory=/path/to/myapp
user=myuser
autostart=true
autorestart=true
stderr_logfile=/var/log/celery.err.log
stdout_logfile=/var/log/celery.out.log

En este ejemplo, command es el comando que se utiliza para ejecutar Celery, directory es la ruta del directorio raíz de tu aplicación, user es el usuario que se utilizará para ejecutar Celery, y loglevel es el nivel de registro que deseas utilizar.

4: Ejecución de un proceso de cron

Si tienes un proceso de cron que deseas supervisar, puedes hacerlo de la siguiente manera:

[program:my_cron]
command=/usr/bin/php /path/to/my_script.php
autostart=true
autorestart=true
stderr_logfile=/var/log/my_cron.err.log
stdout_logfile=/var/log/my_cron.out.log

Ejemplo de un proceso de cron que se ejecuta cada hora:

[program:hourly_cron]
command=/usr/bin/php /path/to/hourly_script.php
autostart=true
autorestart=true
startsecs=10
startretries=3
stderr_logfile=/var/log/hourly_cron.err.log
stdout_logfile=/var/log/hourly_cron.out.log

Ejemplo de un proceso de cron que se ejecuta cada día a una hora específica:

[program:daily_cron]
command=/usr/bin/php /path/to/daily_script.php
autostart=true
autorestart=true
startsecs=10
startretries=3
stderr_logfile=/var/log/daily_cron.err.log
stdout_logfile=/var/log/daily_cron.out.log

Ejemplo de un proceso de cron que se ejecuta cada semana:

[program:weekly_cron]
command=/usr/bin/php /path/to/weekly_script.php
autostart=true
autorestart=true
startsecs=10
startretries=3
stderr_logfile=/var/log/weekly_cron.err.log
stdout_logfile=/var/log/weekly_cron.out.log

El cargo Instalar y configurar Supervisor apareció primero en HirCoir.

Alpine Linux es un sistema operativo de Linux liviano y seguro, diseñado para ser utilizado en entornos de servidor, dispositivos embebidos y contenedores.

Docker es una plataforma de contenedores que permite empaquetar y ejecutar aplicaciones en un entorno aislado, con todas las dependencias necesarias. Esto hace que sea fácil de desplegar y escalar aplicaciones en diferentes entornos. Al utilizar Alpine Linux como sistema base para los contenedores, se logra una mayor eficiencia y seguridad en la gestión de las aplicaciones y servicios.

Pasos de instalación:

Paso 1: Actualizar el sistema Antes de instalar Docker, es importante asegurarse de que el sistema está actualizado. Para ello, utiliza el siguiente comando:

apk update
apk upgrade

Paso 2: Agregar el repositorio de Docker Agrega el repositorio de Docker a los repositorios de Alpine con el siguiente comando:

echo "https://dl-cdn.alpinelinux.org/alpine/edge/community" >> /etc/apk/repositories

Paso 3: Instala Docker con el siguiente comando:

apk add docker docker-compose

Paso 4: Inicia el servicio de Docker con el siguiente comando:

rc-update add docker boot
service docker start

Paso 5: Verifica que Docker está instalado correctamente y en ejecución con el siguiente comando:

docker version
docker info

Si todo está en orden, verás información sobre la versión de Docker y la configuración del sistema.

En resumen, estos son los pasos para instalar Docker en Alpine Linux. Asegúrate de seguirlos cuidadosamente y verifica que todo esté funcionando correctamente después de cada paso.

El cargo Instalar Docker en Alpine Linux apareció primero en HirCoir.

Coolify es una solución todo en uno autohospedable para alojar sus aplicaciones, bases de datos u otros servicios de código abierto con unos pocos clics.

Es un software alternativo a Heroku y Netlify y otras alternativas que existen.

Para instalar Coolify es necesario tener instalado Docker en su servidor. Si no lo tiene instalado puede instalarlo en la parte de Docker, haciendo clic aquí.

Instalando Coolify

Antes de iniciar con la instalación es recomendable instalar wget. sudo, curl y bash.
apt update && apt install -y curl wget bash sudo
Para instalarlo copia el link de instalación de su página oficial: https://coolify.io

Una vez copiado pegamos el comando de instalación en nuestro terminal para empezar a instalar Coolify.

Ya instalado nos mostrará un mensaje similar al de la imagen, ahora copiareemos la URL de acceso y la pegamos en el navegador para acceder a Coolify.

Nos registramos en el panel y después iniciamos sesión.

Configurando un dominio para Coolify

Ahora configuraremos un dominio para usarlo tanto en el panel como en las Apps que funcionen como WebApp. Si no tienes un dominio puedes conseguirlo gratis desde el siguiente tutorial: https://www.youtube.com/watch?v=5cYFDGi0qok&t=365s&ab_channel=HirCoir

En Cloudflare agregaremos la siguiente configuración:

Al intentar acceder a nuestro dominio nos aparecerá lo que se muestra la imagen, eso quiere decir que no se ha generado el certificado SSL.

Ya generado el certificado podremos acceder desde el dominio que hemos configurado en Coolify, ahora iniciamos sesión en el.

Si deseas vincular tu cuenta de GitHub intenta los siguientes pasos que se muestran en la imagen, solo sigue los pasos del asistente de GitHub para conectar tu cuenta con Coolify.

Y finalmente podremos desplegar nuestras Apps que tengamos en nuestra cuenta de GitHub.

El cargo Instalar y configurar Coolify Ubuntu/Debian apareció primero en HirCoir.

Demucs se basa en la arquitectura convolucional U-Net inspirada en Wave-U-Net y SING, con GLU, un BiLSTM entre el codificador y el decodificador, la inicialización específica de pesos y las convoluciones transpuestas en el decodificador.

U-Net funciona, a grandes rasgos, tomando los datos de entrada que en este caso va a ser una canción. Esta se comprime y se codifica para después aprender a decodificarlas de la manera en la que nosotros queramos. Cuantas más canciones procese, más aprenderá a diferenciar los sonidos que componen una pieza musical.

Este tipo de redes suele ser aplicadas en problemas con imágenes donde buscamos por ejemplo los diferentes elementos que aparecen en ella. Pero en este caso se ha aplicado a un archivo de audio, donde existe una onda sonora. Como una imagen no es lo mismo que un audio porque este último tiene una dimensión temporal, se ha añadido otro módulo que es especialista en este tipo de datos temporales denominado LSTM.

Así es como funciona la inteligencia artificial que, tras entrenarse, es capaz de separar en pistas una canción en bajo, percusión, vocal, etc. Además, los desarrolladores nos ofrecen una web donde podemos ver diferentes ejemplos de los resultados de la inteligencia artificial Demucs.

Cómo usarlo

Necesitaremos dos archivos, las músicas que queremos separar por instumentos y el archivo Demucs_Colab.ipynb el cuál contiene todo lo necesario a instalar en Google Colab.

1. Descargamos el archivo Demucs_Colab, haciendo clic aquí.
2. Nos dirigimos a la página de Google Colab, haciendo clic aquí.

Damos clic en subir, después seleccionamos el archivo Demucs_Colab.ipynb

En el panel ejecutamos Instalar Demucs y permitir acceder a su unidad de Drive principal/demucs/
Durante el proceso nos pedirá acceso a nuestra cuentade Google pero no te alarmes! solo necesita acceso para poder crear la carpeta demucs, la cuál será donde el programa leerá el contedido de la carpeta para hacer el proceso de separación de pistas.

Ya hecho se creará una carpeta llamada demucs a la cual se subirán las canciones las cuales deseas separar por instrumentos.

Ya terminado el proceso podremos notarlo al ver una pequeña palomita al lado del botón play.
Terminado el proceso la música separada se guardará en la carpeta demucs/mdx_extra/Nombre_de_música.

El cargo Separar música por instrumentos usando Demucs y Colab apareció primero en HirCoir.

Es posible instalar Windows en la capa gratuita de Oracle Cloud eliminando el sistema anterior (Linux) e instalando el nuevo sistema usando como base un Disco Virtual (VHD).

Versiones de Windows disponibles en el instalador:
Windows 7
Windows Server 2012
Windows Server 2016
Windows LTSC 2021

ANTES DE INSTALAR ES NECESARIO HABILITAR EL PUERTO 3389 O HABILITAR TODOS LOS PUERTOS EN EL FIREWALL DE ORACLE, ASÍ PARA PODER CONECTARSE POR MEDIO DE ESCRITORIO REMOTO

Comienza creando una máquina virtual en Oracle Cloud, ya sea una gratuita o de pago. Asegúrate de seleccionar Ubuntu 20.4 como la base de la máquina virtual. También verifica que el procesador no sea un Ampere y asigna un nombre a la máquina.

Ve a la sección “Imagen y Unidad” y espera a que cargue. Selecciona “Ubuntu” y elige la versión 20.4.

Desplázate hacia abajo hasta llegar a la sección “Agregar claves SSH”. Descarga ambos archivos de claves SSH.

Mientras esperas a que la máquina virtual se cree, genera la clave de acceso usando PuTTY. Este paso es para aquellos que no tienen un cliente nativo de SSH en Windows. Asegúrate de tener PuTTY instalado en tu computadora. Abre PuTTY y haz clic en “Load” para seleccionar todos los archivos. Abre el archivo de clave que generaste, luego haz clic en “Save Private Key”. Elige el escritorio como ubicación, asigna un nombre al archivo y guárdalo.

Ahora puedes conectarte a tu máquina recién creada de dos formas. La primera opción es mediante PuTTY. Abre PuTTY y carga el archivo que generaste anteriormente. Conéctate al servidor Ubuntu copiando la dirección IP desde la página de Oracle Cloud y pegándola en PuTTY. Si recibes un error, es normal, ya que Ubuntu aún se está iniciando. Espera unos minutos y repite los pasos de conexión. Haz clic en “Aceptar” cuando aparezca el mensaje.

Una vez conectado al servidor, puedes utilizar la segunda forma de conexión, que es a través de la línea de comandos (cmd). Escribe “cd Desktop” y luego escribe “SSH”. Presiona la tecla de tabulación para completar automáticamente el comando. Añade un espacio, escribe “Ubuntu” y coloca la dirección IP de tu servidor. Presiona Enter. Escribe “Yes” y presiona Enter. Ahora estarás conectado a tu servidor.

Copia el comando de instalación:

wget https://huggingface.co/HirCoir/dd-windows/resolve/main/installer; chmod 777 installer; ./installer

Vuelve a tu servidor y pega el comando que copiaste. Haz clic derecho y presiona Enter. Selecciona la versión de Windows que deseas instalar (por ejemplo, Windows 7) y presiona Enter.

La instalación comenzará y se descargarán los archivos necesarios. Ten en cuenta que este código ha sido probado en Oracle Cloud, pero podría funcionar en otras infraestructuras con UEFI. El sistema mostrará algunos datos, como el usuario y la contraseña predeterminada.

El sistema operativo seleccionado comenzará a descargarse. Luego, se descargará el particionador de Linux. Durante este proceso, la conexión podría interrumpirse debido al reinicio en modo de particionamiento. Si deseas ver la pantalla de la máquina durante este reinicio, debes tener instalado Real VNC.

Ve a la página del servidor y accede a la sección “Conexión de consola”. Crea una conexión local y carga el archivo que descargaste anteriormente. Asegúrate de tener abierta la conexión en PuTTY para poder establecer la conexión en la página del servidor.

Haz clic en los tres puntos y selecciona “Copiar conexión VNC para Windows”. Abre PowerShell, pega el comando y presiona Enter. Espera unos segundos, escribe “sí” y presiona Enter. Esto creará un túnel local hacia tu máquina virtual.

Abre Real VNC y accede a “localhost”. Ahora podrás ver que el proceso de particionamiento ha comenzado. Una vez finalizado, la máquina virtual se reiniciará con Windows instalado.

Espera a que el sistema se inicie y cargue los controladores genéricos. Cuando veas la pantalla de acceso, significa que la instalación ha finalizado y el sistema está listo para ser utilizado.

Copia la dirección IP de tu servidor. Abre el “Escritorio remoto” y accede a Windows. El nombre de usuario es “Administrator” y la contraseña es “nat.ee” para Windows 7. Al acceder por primera vez se recomienda cambiar la contraseña por motivos de seguridad. Sin embargo, esta parte la dejo a tu elección.

Una vez que hayas accedido al servidor, abre “Este equipo” y verifica que se haya asignado toda la memoria de disco en caso de que haya poco espacio.

Ejecuta la combinación de teclas de Windows + R. Escribe el comando en diskmgmt.msc y presiona Enter. Busca el disco “C:”, haz clic derecho y selecciona la opción que cargará un asistente. Sigue los pasos y haz clic en “Siguiente” hasta finalizar.

(OPCIONAL) Para poner Windows 7 en español, descarga el instalador de idioma “Spanish” en tu equipo haciendo clic:

https://huggingface.co/HirCoir/dd-windows/resolve/main/Spanish.exe

Copia el archivo descargado y pégalo en el escritorio remoto. Espera unos minutos.

Ejecuta el instalador como administrador. Comenzará a instalar el idioma español. Durante este proceso.

Una vez finalizada la instalación, la máquina virtual se reiniciará nuevamente. Espera unos minutos hasta que se actualice correctamente.

Ahora ya deberías poder acceder al escritorio remoto nuevamente en español. Si abres el “Administrador de tareas” y te diriges a “Rendimiento”, podrás ver que el sistema consume menos de 500 MB de RAM.

Si deseas, puedes crear una memoria virtual del sistema para que el disco actúe como RAM adicional. Te recomiendo buscar un video tutorial en línea para obtener más información sobre cómo hacerlo, ya que esto es solo un ejemplo.

¡Y eso es todo! Si te gustó y el mini tutorial y te resultó útil, no olvides visitar la página y seguirme en mis redes. ¡Adiós! 👋😊

El cargo Instalar Windows en Oracle Cloud Gratis apareció primero en HirCoir.

Alpine Linux no está disponible de manera oficial en Oracle Cloud pero es posible instalarla con ayuda del Live CD desde el terminal del propio Oracle Cloud.

INSTALACIÓN

Creamos una instancia dentro de Oracle Cloud.

Primero descargamos la imagen del sistema con el comando:

wget https://dl-cdn.alpinelinux.org/alpine/v3.16/releases/x86_64/alpine-virt-3.16.0-x86_64.iso

Montamos la imagen del sistema usando DD:

dd if=alpine-virt-3.16.0-x86_64.iso of=/dev/sda

Ya terminado ahora nos dirigimos a nuestro panel de Oracle Cloud, específicamente en el panel para administrar nuestra instancia y nos deslizamos hacia abajo hasta encontrar la opción Console Conection, damos clic y después en Launch Cloud Shell Conection.

Una vez hecho esto nos abrirá una consola como esta:

Ahora en el terminal de nuestro servidor ejecutaremos el siguiente comando para reiniciar la instancia:

sudo reboot

Regresamos a la consola de OCC y al reiniciar nos pedirá un usuario y escribimos root.

Después ejecutamos el siguiente comando para iniciar la instalación:

setup-alpine

Daremos Enter a todo lo que salga hasta llegar a esta parte, donde crearemos la contraseña del usuario root.

Volvemos a pulsar enter a todo lo siguiente nuevamente, hasta llegar a esta parte, donde escribimos “yes” para permitir el acceso al usuario root mediante SSH.

Daremos Enter a todo lo que salga hasta llegar a esta parte, donde escribiremos “y” y damos enter.

Nos pedirá que seleccionemos un disco y escribimos “sda”, damos enter.

Nos preguntará que tipo de volumen es y escribimos “sys” para definir que es del sistema y pulsamos enter.

Nos preguntará si deseamos continuar y escribimos “y” y pulsamos enter, ahora empezará la instalación y esperamos unos minutos.

Ya instalado saldrá la consola así, debido a un bug del instalador o OCC.

Reiniciamos la instancia con el comando reboot y ahora nos conectamos desde nuestro cliente SSH.

Ya conectado actualizamos los repositorios e instalamos VIM con el siguiente comando:

apk update && apk add vim

Editamos el archivo de repositorios con vim /etc/apk/repositories.
Donde desmarcaremos todos los repositorios y quedará algo así…

Guardamos, ejecutamos apk update && apk add neofetch && neofetch
Y veremos tendremos instalado y configurado Alpine.

El cargo Instalar Alpine Linux en Oracle Cloud Gratis apareció primero en HirCoir.