<![CDATA[ _ voidNull ]]> https://voidnull.es es _ voidNull Copyright 2024 https://voidnull.es/favicon.png _ voidNull https://voidnull.es Fri, 29 Mar 2024 10:01:43 +0100 <![CDATA[ Configurar CloudFlare en Home Assistant: Accede de forma segura con tu dominio ]]> https://voidnull.es/configurar-cloudflare-en-home-assistant-accede-de-forma-segura-con-tu-dominio/ 65de3a90add21a0cbc977746 Thu, 28 Mar 2024 10:29:56 +0100 Configurar CloudFlare para trabajar con Home Assistant te permitirá acceder a tu sistema domótico de manera segura utilizando tu propio dominio, además de aprovechar las ventajas que CloudFlare ofrece como CDN, protección contra DDoS, y una capa adicional de seguridad. Este artículo te guiará paso a paso para configurar CloudFlare con Home Assistant.

Registrar un dominio

Para seguir este tutorial necesitaremos un dominio registrado en nuestra posesión. Hay infinidad de proveedores para registrar dominios. Buscad por Internet y sobretodo comparar precios entre los diferentes servicios. Cuando tengáis el precio y el dominio seleccionado, id a por ello.

Registro en CloudFlare

También para seguir con este tutorial, tendremos que estar registrados en CloudFlare, para hacerlo tenemos que seguir las instrucciones que hay en este enlace.

Configurar dominio en CloudFlare

Iniciamos sesión en CloudFlare y hacemos clic sobre Sitios Web y hacemos clic sobre el botón Comenzar.

El siguiente paso es activar el plan de nuestra cuenta. Para este propósito con el plan gratuito es suficiente.

Tras darle a Continuar importará los registros que detecte en nuestra zona DNS. Si nos interesa los podemos copiar, si no se puede eliminar y continuar el proceso.

El siguiente paso, nos indicará que tenemos que cambiar los NS de nuestro dominio. Para ello tendremos que ir a nuestro proveedor de dominios y configurarlos

Comprobar NS del dominio

Para comprobar si se han replicado correctamente los NS en nuestro dominio podemos utilizar la web intodns.com o bien utilizar el comando dt:

dt: Una herramienta CLI para mostrar información sobre su dominio
El comando dt es una herramienta bajo licencia Apache 2.0 escrita en Go. Es una herramienta CLI para DNS que muestra información sobre un dominio. En la actualidad, tiene las siguientes características: * Soporte de escáner de registros comunes (Tipo A, CNAME, TXT, etc). * Validación de cadenas DNSSEC. * Modificar la

Forzar la comprobación de los NS

En CloudFlare podemos forzar la comprobación de los NS, aunque por lo generar el mismo CloudFlare lo irá revisando cada cierto tiempo. Para hacerlo manualmente deberemos de hacer clic sobre el botón Compruebe los servidores de nombre ahora:

Añadir complemento a Home Assistant

Para utilizar CloudFlare en Home Assistant lo haremos a partir de un complemento creado por la comunidad. Para ello debemos de ir a Ajustes - Complementos y hacemos clic en Tienda de Complementos.

Arriba a la derecha, hacemos clic sobre los tres puntos y luego a Repositorios. Lo que haremos es añadir un repositorio nuevo. Concretamente este:

https://github.com/brenner-tobias/ha-addons

Luego actualizamos la página y seleccionamos el complemento Cloudflared y hacemos clic en Instalar:

Nos vamos a la pestaña de Configuración y añadimos nuestro dominio en External Home Assistant Hostname:

💡
Por el momento no iniciaremos el complemento!

Crear registro en CloudFlare

Una vez tu dominio responda correctamente con los nuevos NS, deberemos de ir al apartado de DNS - Records. Para añadir un registro nuevo haremos clic sobre Add Record y deberemos de rellenar los datos:

  • Type: A
  • Name: Lo dejaremos en blanco para acceder directamente a nuestro dominio. Si queremos usar un subdominio, entonces allí escribiremos el subdominio.
  • IPv4: Pondremos cualquier IP, esto luego se cambiará automáticamente.
  • Proxy Status: Lo desactivamos.

Modificar la configuración de Home Assistant

Ahora necesitamos modificar la configuración de nuestro Home Assistant, para ello usaremos nuestro complemento de edición de ficheros favorito y editaremos el fichero configuration.yml con lo siguiente:

http:
  use_x_forwarded_for: true
  trusted_proxies:
    - 172.30.33.0/24

Guardamos el fichero y reiniciamos nuestro Home Assistant.

Después de reiniciar, iremos a Ajustes - Sistema - Red y habilitaremos la IPv4 como Estática.

Habilitar complemento Cloudflared

Ahora nos vamos de nuevo donde nuestro complemento en Ajustes - Complementos hacemos clic sobre el complemento e iniciamos:

Al iniciar, nos vamos a la pestaña Registros y veremos que en los registros hay una URL:

Tenemos que acceder a esa URL y aceptar el túnel que se creará en nuestra cuenta de CloudFlare. Haremos clic en Authorize:

Volvemos a nuestro Home Assistant y actualizamos la página, deberemos de ver que la integración carga correctamente el túnel:

Registros del complemento

[18:58:04] INFO: Checking add-on config...
[18:58:04] INFO: Checking for existing certificate...
[18:58:04] INFO: Existing certificate found
[18:58:04] INFO: Checking for existing tunnel...
[18:58:04] INFO: Existing tunnel with ID 7b21e8d3-XXX-4e4f-XXX-61472XXX4f2 found
[18:58:04] INFO: Checking if existing tunnel matches name given in config
[18:58:04] INFO: Existing Cloudflare Tunnel name matches config, proceeding with existing tunnel file
[18:58:04] INFO: Creating config file...
[18:58:04] INFO: Validating config file...
Validating rules from /tmp/config.json
OK
[18:58:04] INFO: Creating DNS entry tutos.site...
2024-02-28T17:58:05Z INF tutos.XXX is already configured to route to your tunnel tunnelID=7b21e8d3-XXX-4e4f-XXX-61472XXX4f2
[18:58:05] INFO: Finished setting up the Cloudflare Tunnel
[18:58:05] INFO: Connecting Cloudflare Tunnel...
2024-02-28T17:58:05Z INF Starting tunnel tunnelID=7b21e8d3-XXX-4e4f-XXX-61472XXX4f2
2024-02-28T17:58:05Z INF Version 2024.2.1
2024-02-28T17:58:05Z INF GOOS: linux, GOVersion: go1.21.5, GoArch: amd64
2024-02-28T17:58:05Z INF Settings: map[config:/tmp/config.json cred-file:/data/tunnel.json credentials-file:/data/tunnel.json loglevel:info metrics:0.0.0.0:36500 no-autoupdate:true origincert:/data/cert.pem]
2024-02-28T17:58:05Z INF Generated Connector ID: 3ddbd2b2-0800-4be1-8992-1655ce45b1a2
2024-02-28T17:58:05Z INF Initial protocol quic
2024-02-28T17:58:05Z INF ICMP proxy will use 172.30.33.1 as source for IPv4
2024-02-28T17:58:05Z INF ICMP proxy will use :: as source for IPv6
2024-02-28T17:58:06Z INF Starting metrics server on [::]:36500/metrics
2024-02-28T17:58:06Z INF Registered tunnel connection connIndex=0 connection=b74d085d-591b-41c1-bdaa-36ff173f9e54 event=0 ip=198.41.200.33 location=mad04 protocol=quic
2024-02-28T17:58:06Z INF Registered tunnel connection connIndex=1 connection=a2e8d323-d637-4fe5-8c99-df70c7c6c5c5 event=0 ip=198.41.192.67 location=bcn01 protocol=quic
2024-02-28T17:58:07Z INF Registered tunnel connection connIndex=2 connection=7ce2bd81-b69c-4cf0-949d-f054a7bd2cfc event=0 ip=198.41.192.7 location=bcn01 protocol=quic
2024-02-28T17:58:08Z INF Registered tunnel connection connIndex=3 connection=dcf1fe76-9ab7-4dfa-9c7e-a11eff0c4a97 event=0 ip=198.41.200.23 location=mad03 protocol=quic

En este momento ya podemos acceder a nuestro Home Assistant utilizando el dominio que hemos configurado.

💡
Si al cargar te da un error de SSL, en CloudFlare entra en SSL/TLS - Edge Certificates y revisa que el estatus se encuentra en Active. También en el apartado SSL/TLS - Overview la encriptación se encuentra en Flexible.
]]>
<![CDATA[ telnet: comandos en remoto y respuestas a puertos ]]> https://voidnull.es/telnet-comandos-en-remoto-y-respuestas-a-puertos/ 65e8afe4add21a0cbc978014 Wed, 27 Mar 2024 10:19:04 +0100 Telnet, acrónimo de "Telecommunication Network", es un protocolo de red utilizado para proporcionar una comunicación bidireccional interactiva basada en texto a través de una terminal virtual.

Es parte del conjunto de protocolos de Internet y se utiliza principalmente para acceder a servidores remotos y dispositivos de red. Aunque Telnet ha sido ampliamente reemplazado por protocolos más seguros como SSH (Secure Shell) para la mayoría de sus usos, todavía se encuentra en algunos entornos, especialmente en la educación, para fines de diagnóstico y para equipos de red que no soportan protocolos más modernos.

¿Para qué sirve?

Telnet permite a los usuarios ejecutar comandos en un sistema remoto como si estuvieran sentados frente a él, facilitando la administración de sistemas y la configuración de dispositivos de red. Sin embargo, debido a que transmite los datos, incluidas las credenciales de inicio de sesión, en texto plano sin cifrado, su uso se considera inseguro para la transmisión de información sensible.

Sintaxis básica

La sintaxis básica para el comando Telnet es la siguiente:

telnet [dirección_host] [puerto]

Donde:

  • [dirección_host] es la dirección IP o el nombre de dominio del servidor al que deseas conectarte.
  • [puerto] es el número de puerto TCP en el servidor al que se establecerá la conexión. Si no se especifica, Telnet utiliza el puerto predeterminado 23.

Algunos ejemplos

A continuación pasamos a detallar algunas opciones interesantes del comando.

Conectarse a un Servidor Remoto

Para conectarse a un servidor remoto en el puerto predeterminado:

telnet voidnull.es

Especificar un Puerto

Si necesitas conectarte a un servicio específico en un puerto diferente, como un servidor web en el puerto 80:

telnet voidnull.es 443

Utilizar un Nombre de Usuario Específico

Para iniciar sesión con un nombre de usuario específico:

telnet -l usuario ejemplo.com

Abrir una Conexión Dentro de Telnet

Si ya estás en el prompt de Telnet y quieres conectarte a otro servidor:

telnet
open otro.ejemplo.com 80

Conclusión

Aunque Telnet es un protocolo antiguo y no recomendado para el uso en entornos de producción debido a sus debilidades de seguridad, sigue siendo una herramienta útil para la enseñanza y la administración de ciertos dispositivos de red en entornos controlados. Siempre se recomienda utilizar alternativas más seguras como SSH para tareas que involucren la transmisión de información sensible.

]]>
<![CDATA[ Instalación de un nodo de Mastodon en Ubuntu 22.04 ]]> https://voidnull.es/instalacion-de-un-nodo-de-mastodon-en-ubuntu-22-04/ 65e9eed0add21a0cbc978175 Tue, 26 Mar 2024 10:57:39 +0100 Mastodon es una red social libre y descentralizada de microblogging. Esta red social es una federación descentralizada de servidores que ejecutan el Software bajo licencia AGPL.

Eso significa que los usuarios están esparcidos en diferentes comunidades autónomos e independientes llamadas "instancias" o "nodos" cuya red se llama Fediverso (que viene de unir Federeación + Universo).

Pasos previos

Para realizar este tutorial será necesario tener un servidor Ubuntu 22.04 con acceso a root. Además también necesitaremos tener un dominio o subdominio donde hacer la instalación de la instancia de Mastodon.

Instalación de NodeJS

Para poder instalar NodeJS, deberás de seguir las instrucciones de este otro tutorial:

Instalación de NodeJS en GNU/Linux [Debian, Ubuntu, CentOS]
En el siguiente tutorial os explicaremos la correcta instalación de NodeJS en GNU/Linux. Ya sea tu servidor un Ubuntu o Debian o CentOS aquí encontrarás las instrucciones correctas para su instalación.

Es recomendable instalar la versión LTS.

# node -v
v16.17.0

Instalación de Yarn

También será necesario añadir el repositorio de Yarn para la versión de Mastodon.

curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
apt update

Y lo instalamos:

apt install yarn

Instalación de dependencias

También son necesario instalar todas estas dependencias:

apt -y install imagemagick ffmpeg libpq-dev libxml2-dev libxslt1-dev file git-core g++ libprotobuf-dev protobuf-compiler pkg-config gcc autoconf bison build-essential libssl-dev libyaml-dev libreadline-dev zlib1g-dev libncurses5-dev libffi-dev libgdbm-dev libidn11-dev libicu-dev libjemalloc-dev

Instalación de Nginx, Redis, Certbot y PostgreSQL

Software necesario para Mastodon, necesitaremos un servidor web, que en este caso será de nuevo Nginx, también usaremos Redis para la caché y luego para las bases de datos usaremos PostgreSQL.

apt install nginx redis-server redis-tools postgresql-15 certbot

Habilitamos los servicios al arranque:

systemctl enable nginx

Dependencias que deben de ser añadidas por un usuario no-root

Creamos un usuario llamado mastodon:

adduser mastodon

Iniciamos como el usuario que hemos creado:

su - mastodon

Instalamos los siguientes paquetes rbenv y ruby-build:

git clone https://github.com/rbenv/rbenv.git ~/.rbenv
cd ~/.rbenv && src/configure && make -C src
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
# Reiniciamos la shell
exec bash
# Comprobamos que rbenv está bien instalado
type rbenv
# Instalamos ruby-build
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build

Ahora que ya están instalados los paquetes rbenv y ruby-build podemos proceder a la instalación de la versión de Ruby que Mastodon necesita, y para habilitarlo es necesario ejecutar lo siguiente:

RUBY_CONFIGURE_OPTS=--with-jemalloc rbenv install 3.2.3
rbenv global 3.2.3

Esto llevará un tiempo seguramente, así que por ejemplo, yo me fui hacer un café y aún estaba instalando.

Dependencias para NodeJS y Ruby

Ahora que Ruby está habilitado, vamos a clonar el repositorio de Mastodon y luego instalaremos las dependencias de Ruby y NodeJS.

Primero volvemos al home de nuestro usuario mastodon:

cd

Clonamos el repositorio de Mastodon:

git clone https://github.com/tootsuite/mastodon.git live

Accedemos dentro de la carpeta creada:

cd live

Instalamos Bundler:

gem install bundler

Usamos Bundler para instalar el resto de dependencias para Ruby:

bundle config deployment 'true'
bundle config without 'development test'
bundle install -j$(getconf _NPROCESSORS_ONLN)

Y usamos Yarn para instalar las dependencias de NodeJS:

yarn install --pure-lockfile

Una vez hemos acabado con esto, ejecutamos exit para salir del usuario mastodon y volver al usuario root.

Creación de la base de datos

Ahora crearemos la base de datos para Mastodon con PostgreSQL, para ello accederemos al prompt:

sudo -u postgres psql

Crearemos la base de datos:

CREATE USER mastodon CREATEDB;

Y salimos:

exit

La contraseña del usuario será que la hemos configurado para el propio sistema.

Configuración Nginx

En la documentación, te dan el fichero de configuración de Nginx preparado para copiar y utilizar, así que vamos a copiar el fichero directamente:

cp /home/mastodon/live/dist/nginx.conf /etc/nginx/sites-available/mastodon.conf
ln -s /etc/nginx/sites-available/mastodon.conf /etc/nginx/sites-enabled/mastodon.conf

Editamos el fichero de configuración /etc/nginx/sites-available/mastodon.conf y modificamos example.com por nuestro dominio.

Reiniciamos Nginx para aplicar los cambios:

systemctl reload nginx

Configuración de Nginx con SSL

El siguiente paso será crear el certificado para nuestro dominio, así que instalaremos los paquetes necesarios para hacerlo con Let's Encrypt:

apt install certbot python3-certbot-nginx

Creamos el certificado:

certbot --nginx -d nuestrodominio.com

Instalación de Mastodon

¡Venga, que ya queda poco! Volvemos a iniciar sesión como el usuario mastodon:

su - mastodon

Ahora viene lo interesante. Iniciaremos la instalación donde tendremos una configuración interactiva donde nos pedirá información de nuestra instancia de Mastodon:

cd live
RAILS_ENV=production bundle exec rake mastodon:setup

Esta es la salida del comando y las respuestas que debéis de introducir para configurar vuestro nodo de Mastodon:

Your instance is identified by its domain name. Changing it afterward will break things.
Domain name: [NuestroDominio]

Single user mode disables registrations and redirects the landing page to your public profile.
Do you want to enable single user mode? No

Are you using Docker to run Mastodon? no

PostgreSQL host: /var/run/postgresql
PostgreSQL port: 5432
Name of PostgreSQL database: mastodon
Name of PostgreSQL user: mastodon
Password of PostgreSQL user: [Contraseña del usuario mastodon]
Database configuration works! 🎆

Redis host: localhost
Redis port: 6379
Redis password: 
Redis configuration works! 🎆

Do you want to store uploaded files on the cloud? No

Do you want to send e-mails from localhost? yes
E-mail address to send e-mails "from": mastodon@[nuestroDominio]
Send a test e-mail with this configuration right now? Yes
Send test e-mail to: [TuCuentaDeCorreo]

This configuration will be written to .env.production
Save configuration? Yes

Now that configuration is saved, the database schema must be loaded.
If the database already exists, this will erase its contents.
Prepare the database now? Yes
Running `RAILS_ENV=production rails db:setup` ...

Created database 'mastodon'
Done!

The final step is compiling CSS/JS assets.
This may take a while and consume a lot of RAM.
Compile the assets now? Yes

La última pregunta que nos hace, es si queremos compilar los assets, le diremos que si para que compile todo:

Running `RAILS_ENV=production rails assets:precompile` ...

yarn install v1.22.19
[1/6] Validating package.json...
[2/6] Resolving packages...
[3/6] Fetching packages...
[4/6] Linking dependencies...
warning Workspaces can only be enabled in private projects.
[5/6] Building fresh packages...
[6/6] Cleaning modules...
Done in 8.87s.
Compiling...
Compiled all packs in /home/mastodon/live/public/packs
Browserslist: caniuse-lite is outdated. Please run:
npx browserslist@latest --update-db

Why you should do it regularly:
https://github.com/browserslist/browserslist#browsers-data-updating

Done!

All done! You can now power on the Mastodon server 🐘

Tras este proceso, tendremos Mastodon funcionando en nuestro servidor, pero antes, podemos crear un usuario admin para gestionar el nodo:

Do you want to create an admin user straight away? Yes
Username: root
E-mail: mastodon@[nuestroDominio]
You can login with the password: a17dbxxxxxxxxxxx6b2fdb5399
You can change your password once you login.

Este proceso generará una contraseña automáticamente que será la que usaremos para iniciar con nuestro usuario admin y que podemos cambiar posteriormente.

Configuración de SystemD para Mastodon

Hay que configurar tres servicios para poder iniciar el servicio de manera más sencilla. Estos son los tres ficheros y su contenido:

Tendremos que copiar los ficheros de los servicios directamente del repositorio:

cp /home/mastodon/live/dist/mastodon-*.service /etc/systemd/system/

Los habilitamos para el arranque:

systemctl daemon-reload
systemctl enable --now mastodon-web mastodon-sidekiq mastodon-streaming

Y una vez hemos acabado con esto… *redoble de tambores* Ta chaaaaan! Ya tenemos Mastodon en nuestro servidor y funcionando perfectamente.

Sólo faltará que la federación haga lo suyo para empezar a ver toda la red disponible 😛

]]>
<![CDATA[ Cambiar puerto de acceso para Home Assistant ]]> https://voidnull.es/cambiar-puerto-de-acceso-para-home-assistant/ 65df5f68add21a0cbc9778fa Mon, 25 Mar 2024 10:51:45 +0100 De forma predeterminada, Home Assistant se ejecuta en el puerto 8123, pero hay ocasiones en las que podemos tener la necesitar cambiar este puerto.

Ya sea por requisitos de seguridad, por conflictos con otros servicios que se ejecutan en el mismo servidor, o simplemente por preferencias personales, cambiar el puerto de Home Assistant es un proceso relativamente sencillo.

Modificar el puerto de acceso

Para modificar el puerto de acceso, deberéis de acceder a Home Assistant y abrir vuestro editor favorito, ya sea Studio Code o File Editor, y editar el fichero de configuración configuration.yaml.

En el fichero de configuración buscaremos el parámetro http y añadiremos lo siguiente:

http:
  server_port: 9000

Guardamos el fichero y vamos a Herramientas para desarrolladores - Verificar configuración para verificar la configuración nueva aplicada.

Cuando aparezca el mensaje en verde ¡La configuración no impedirá que se inicie Home Assistant! entonces podremos pulsar el botón para Reiniciar Home Assistant.

Una vez reinicie, podremos acceder con el nuevo puerto:

]]>
<![CDATA[ Instalar tu propio Proxy para Telegram con SOCKS5 ]]> https://voidnull.es/instalar-tu-propio-proxy-para-telegram-con-socks5/ 66006914cef1b66a2862eb50 Mon, 25 Mar 2024 09:00:14 +0100 Telegram Messenger tiene soporte para diferentes tipos de servidores proxy: un servidor proxy SOCKS5 estándar y un servidor proxy MTProto.

En este tutorial aprenderemos a construir un servidor proxy SOCKS5. Este estilo de proxy puede ayudarte a evitar la censura en ciertos países.

A continuación aprenderemos a crear un servidor proxy SOCKS5 que implemente el protocolo TLS falso en el mismo host que el servidor web.

Si prefieres montar un servidor con MTProto, puedes hacerlo en el siguiente tutorial:

Instalar tu propio Proxy para Telegram con MTProto
En este tutorial aprenderemos a construir un servidor proxy MTProto. Este estilo de proxy puede ayudarte a evitar la censura en ciertos países.

Requisitos básicos

Para hacer este tutorial necesitaremos un servidor cloud o VPS que disponga de IP de un país el cual Telegram no se encuentre bloqueado.

Este tutorial lo realizaremos con Debian 12, pero se puede usar con diferentes distribuciones de GNU/Linux basadas en Debian.

Necesitaremos también acceso root completo por SSH.

Paso 1: Conectarse al servidor

Lo primero que haremos será conectarnos al servidor. Para ello usaremos SSH y el usuario root. Para conectarnos ejecutaremos lo siguiente:

ssh root@[IP_SERVIDOR]

Con esto, después de introducir la contraseña, ya estaremos conectados al servidor.

root@proxy:~# 

Paso 2: Configurar el Firewall de tu servidor

Muchos proveedores de servidores disponen de un Firewall, en este cortafuegos tendremos que configurarlo de manera que tengamos los siguientes puertos habilitados:

Puerto Uso
22/tcp Acceso SSH, puedes configurar otro si quieres
8443/tcp Acceso SOCKS5

Paso 3: Instalación y configuración de Dante Server

Dante Server es un servidor de SOCKS5 que permite configurar todo lo necesario para utilizarlo en Telegram.

apt install dante-server

Eliminamos el contenido del fichero /etc/danted.conf y añadimos el siguiente:

logoutput: syslog
user.privileged: root
user.unprivileged: nobody

internal: 0.0.0.0 port = 8443

external: eth0

socksmethod: username
clientmethod: none
user.libwrap: nobody
client pass {
        from: 0/0 to: 0/0
        log: connect disconnect error
}

socks pass {
        from: 0/0 to: 0/0
        log: connect disconnect error
}
💡
En el parámetro internal podremos habilitar el puerto que necesitemos, en este caso, usaremos el puerto 8443.
💡
Tendremos que tener en cuenta, que en external deberemos de poner la interfaz de red que queremos usar. Por lo general suele ser eth0 pero puedes comprobar cual es tu interfaz con el comando ip a .

Ahora tendremos que configurar un usuario que usaremos para conectarnos al Proxy:

useradd --shell /usr/sbin/nologin proxyuser

Y le añadimos una contraseña segura:

passwd proxyuser
💡
Para el tutorial hemos creado el usuario proxyuser pero puedes crear los usuarios que necesites con el nombre que quieras. Eso si, una contraseña segura siempre! 😺

Una vez tenemos nuestro fichero de configuración a nuestro gusto, lo guardamos y reiniciamos el servicio:

systemctl restart danted
systemctl enable danted

Podemos comprobar que está escuchando correctamente con:

# ss -tulpn | grep 443
tcp LISTEN 0 511 0.0.0.0:8443 0.0.0.0:* users (("danted",pid=14977,fd=8))     

Paso 4: Generando la configuración del Proxy

Ahora tenemos que construir la URL para configurar el Proxy directamente en Telegram. La estructura de este comando tiene que ser como esto:

# CON HTTPS:
https://t.me/socks?server=[IP_SERVIDOR]&port=[PUERTO]&user=[USUARIO]&pass=[CONTRASEÑA]

# CON TELEGRAM:
tg://socks?server=[IP_SERVIDOR]&port=[PUERTO]&user=[USUARIO]&pass=[CONTRASEÑA]

Deberemos de rellenar los campos de la siguiente forma:

  • IP_SERVIDOR: La IP pública de nuestro servidor
  • PUERTO: El puerto que hayamos habilitado en el fichero de configuración, en este tutorial hemos usado el 8443.
  • USUARIO: El nombre de usuario que hayamos creado.
  • CONTRASEÑA: La contraseña del usuario.

Paso 5: Probando que funciona [Opcional]

Para comprobar que funciona correctamente el Proxy, podemos hacerlo probando con curl, una herramienta genial.

curl -I socks5://proxyuser:[CONTRASEÑA]@[IP_SERVIDOR]:8443 https://voidnull.es

Este comando obtendremos la siguiente respuesta:

HTTP/2 200 
server: nginx/1.18.0
date: Sun, 24 Mar 2024 21:26:11 GMT
content-type: text/html; charset=utf-8
vary: Accept-Encoding
x-powered-by: Express
cache-control: public, max-age=0
etag: W/"12097-ohz7TsFboSPpJzHDxRkuUR91EMU"
vary: Accept-Encoding
x-varnish: 5345170
age: 0
via: 1.1 varnish (Varnish/6.5)
accept-ranges: bytes
access-control-allow-origin: *
access-control-allow-credentials: true
content-security-policy: upgrade-insecure-requests;

Veremos que la respuesta HTTP/2 es con el código de salida 200, lo que significa que la respuesta es correcta.

Paso 6: Conectarse al Proxy desde Telegram

Ahora desde nuestro dispositivo tenemos que abrir la URL que hemos generado para HTTP o TG y abrirla con Telegram:

]]>
<![CDATA[ Instalar tu propio Proxy para Telegram con MTProto ]]> https://voidnull.es/instalar-tu-propio-proxy-para-telegram-con-mtproto/ 65feb2f7cef1b66a2862ea34 Sat, 23 Mar 2024 22:06:34 +0100 Telegram Messenger tiene soporte para diferentes tipos de servidores proxy: un servidor proxy SOCKS5 estándar y un servidor proxy MTProto.

En este tutorial aprenderemos a construir un servidor proxy MTProto. Este estilo de proxy puede ayudarte a evitar la censura en ciertos países.

A continuación aprenderemos a crear un servidor proxy MTProto que implemente el protocolo TLS falso en el mismo host que el servidor web.

Requisitos básicos

Para hacer este tutorial necesitaremos un servidor cloud o VPS que disponga de IP de un país el cual Telegram no se encuentre bloqueado.

Este tutorial lo realizaremos con Debian 12, pero se puede usar con diferentes distribuciones de GNU/Linux basadas en Debian.

Necesitaremos también acceso root completo por SSH. Además, también necesitaremos un nombre de dominio que apunte al servidor.

Paso 1: Conectarse al servidor

Lo primero que haremos será conectarnos al servidor. Para ello usaremos SSH y el usuario root. Para conectarnos ejecutaremos lo siguiente:

ssh root@[IP_SERVIDOR]

Con esto, después de introducir la contraseña, ya estaremos conectados al servidor.

root@proxy:~# 

Paso 2: Configurar el Firewall de tu servidor

Muchos proveedores de servidores disponen de un Firewall, en este cortafuegos tendremos que configurarlo de manera que tengamos los siguientes puertos habilitados:

Puerto Uso
22/tcp Acceso SSH, puedes configurar otro si quieres
443/tcp Acceso HTTPS y de MTProto

Paso 3: Instalación de Nginx

Instalamos ahora Nginx, para ello ejecutamos el siguiente comando:

apt install nginx

Luego editamos /etc/nginx/sites-enabled/default y añadimos el server_name con nuestro dominio:

server_name proxy.voidnull.es;

Guardamos y recargamos Nginx:

systemctl reload nginx

Paso 4: Instalación del SSL

Ahora creamos el certificado SSL con Let's Encrypt siguiendo este otro tutorial:

Cómo utilizar Certbot para configurar un SSL de Let’s Encrypt en GNU/Linux
Certbot es una maravillosa herramienta que puedes utilizar para generar un certificado SSL con Let’s Encrypt e instalarlo y configurar automáticamente en tu servidor web.

Paso 5: Instalación del lenguaje Go

Para instalar el lenguaje Go en nuestro servidor, deberemos de seguir este otro tutorial que explica el proceso detalladamente:

Cómo instalar Go (GoLang) en GNU/Linux
Go, también conocido como GoLang, es un lenguaje de programación. Es de código abierto desarrollado por un equipo de Google y muchos otros colaboradores de la comunidad.

Paso 6: Instalación de Mtg

Ahora tendremos que descargar el repositorio donde se encuentra el Proxy MTProto, así que tendremos que tener instalado Git:

apt install git

Y luego descargamos el repositorio:

git clone https://github.com/9seconds/mtg.git

Accedemos al directorio creado:

cd mtg

Y compilamos el código con Go:

go build

Salida del comando

go build

go: downloading github.com/alecthomas/kong v0.6.1
go: downloading github.com/rs/zerolog v1.27.0
go: downloading github.com/yl2chen/cidranger v1.0.2
go: downloading github.com/OneOfOne/xxhash v1.2.8
go: downloading github.com/tylertreat/BoomFilters v0.0.0-20210315201527-1a82519a3e43
go: downloading github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137
go: downloading github.com/pelletier/go-toml v1.9.5
go: downloading github.com/panjf2000/ants/v2 v2.5.0
go: downloading github.com/babolivier/go-doh-client v0.0.0-20201028162107-a76cff4cb8b6
go: downloading github.com/txthinking/socks5 v0.0.0-20220615051428-39268faee3e6
go: downloading golang.org/x/sys v0.0.0-20220804214406-8e32c043e418
go: downloading github.com/prometheus/client_golang v1.13.0
go: downloading github.com/smira/go-statsd v1.3.2
go: downloading github.com/mattn/go-colorable v0.1.12
go: downloading golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa
go: downloading github.com/patrickmn/go-cache v2.1.0+incompatible
go: downloading github.com/txthinking/runnergroup v0.0.0-20220212043759-8da8edb7dae8
go: downloading github.com/txthinking/x v0.0.0-20210326105829-476fab902fbe
go: downloading github.com/beorn7/perks v1.0.1
go: downloading github.com/cespare/xxhash/v2 v2.1.2
go: downloading github.com/golang/protobuf v1.5.2
go: downloading github.com/prometheus/client_model v0.2.0
go: downloading github.com/prometheus/common v0.37.0
go: downloading github.com/prometheus/procfs v0.8.0
go: downloading google.golang.org/protobuf v1.28.1
go: downloading github.com/mattn/go-isatty v0.0.14
go: downloading github.com/matttproud/golang_protobuf_extensions v1.0.1

Copiamos el ejecutable compilado a la siguiente ruta:

cp mtg /usr/local/bin

Paso 7: Generando la configuración del Proxy

Tendremos que generar un código que usaremos luego para conectarnos, para ello deberemos de escribir este comando con nuestro dominio:

mtg generate-secret proxy.voidnull.es

Obtendremos un código, deberemos de guardarlo para más tarde.

Creamos el fichero /etc/mtg.toml con el siguiente contenido:

secret = "[EL CODIGO QUE HEMOS GENERADO ANTES]"
bind-to = "0.0.0.0:443"
concurrency = 1024
domain-fronting-port = 8443

Paso 8: Crear un servicio para SystemD

Para poder gestionar el servicio más fácilmente, lo que haremos será configurar un servicio de SystemD, creamos el fichero /usr/lib/systemd/system/mtg.service

[Unit]
Description=mtg - MTProto proxy server
Documentation=https://github.com/9seconds/mtg
After=network.target

[Service]
ExecStart=/usr/local/bin/mtg run /etc/mtg.toml
Restart=always
RestartSec=3
DynamicUser=true
AmbientCapabilities=CAP_NET_BIND_SERVICE

[Install]
WantedBy=multi-user.target

Y lo iniciamos:

systemctl daemon-reload
systemctl enable mtg
systemctl start mtg

Servicio levantado

# systemctl status mtg
● mtg.service - mtg - MTProto proxy server
Loaded: loaded (/etc/systemd/system/mtg.service; enabled; preset: enabled)
Active: active (running) since Sat 2024-03-23 21:50:55 CET; 5min ago
Docs: https://github.com/9seconds/mtg
Main PID: 859 (mtg)
Tasks: 15 (limit: 2307)
Memory: 13.7M
CPU: 113ms
CGroup: /system.slice/mtg.service
└─859 /usr/local/bin/mtg run /etc/mtg.toml

Mar 23 21:50:55 proxy systemd[1]: Started mtg.service - mtg - MTProto proxy server.

Paso 9: Conectarse al Proxy desde Telegram

Para conectarnos, deberemos primero de generar un enlace para conectarnos, para ello ejecutaremos el siguiente comando:

mtg access /etc/mtg.toml

Y obtendremos una respuesta similar a esta:

{
  "ipv4": {
    "ip": "XX.XX.XX.XX",
    "port": 443,
    "tg_url": "tg://proxy?port=443&secret=7uD1GulbFgXXXXXXXXX91ZA&server=XX.XX.XX.XX",
    "tg_qrcode": "https://api.qrserver.com/v1/create-qr-code?data=tg%3A%2F%2Fproxy%3Fport%3D443%26secret%3D7uD1GuxXXXXXXXXXG91ZA%26server%3DXX.XX.XX.XX&format=svg&qzone=4",
    "tme_url": "https://t.me/proxy?port=443&secret=7uD1GulbXXXXXXXXXXXXbG91ZA&server=XX.XX.XX.XX",
    "tme_qrcode": "https://api.qrserver.com/v1/create-qr-code?data=https%3A%2F%2Ft.me%2Fproxy%3Fport%3D443%26secret%3D7uDXXXXP9f9auvpwcm94eXXXXXXXXXXX1ZA%26server%3DXX.XX.XX.XX&format=svg&qzone=4"
  },
  "secret": {
    "hex": "eee0f51ae95b160c447881cfXXX617272656c2e636c6f7564",
    "base64": "7uXXXXXXXXXXwcm94eS5hcnJlbC5jbG91ZA"
  }
}

Ahora podremos obtener el enlace tg_url y abrirlo desde Telegram y nos aparecerá lo siguiente para conectarnos:

Le hacemos a Conecta al servidor y nos aparecerá un aviso donde nos avisa de que estamos conectados al Proxy. En este punto todos los datos de Telegram pasarán por ese servidor.

]]>
<![CDATA[ Módulos: Sistema [Ansible #20] ]]> https://voidnull.es/modulos-sistema/ 65e88518add21a0cbc977fb0 Fri, 22 Mar 2024 10:17:49 +0100 Ansible es una herramienta de automatización extremadamente versátil que se utiliza para configurar sistemas, desplegar software, y orquestar tareas avanzadas de TI. Además de su capacidad para gestionar aplicaciones y servicios, Ansible también ofrece varios módulos diseñados específicamente para la administración de aspectos fundamentales del sistema.

En este artículo, exploraremos los módulos cron, filesystem, firewalld, hostname, mount, user, y group, ofreciendo una descripción y ejemplos de código para facilitar su comprensión y aplicación.

Módulo cron

El módulo cron de Ansible se utiliza para gestionar trabajos cron en sistemas Unix/Linux, permitiendo automatizar la ejecución de tareas en momentos específicos.

Este módulo permite agregar, eliminar o asegurar la presencia de trabajos cron, proporcionando una gestión simplificada de tareas programadas.

- name: Añadir un trabajo cron para hacer una copia de seguridad diaria de la base de datos
  cron:
    name: "Copia de seguridad diaria de la base de datos"
    minute: "0"
    hour: "2"
    job: "/usr/bin/pg_dumpall > /var/backups/db_backup"

Este ejemplo crea un trabajo cron para realizar una copia de seguridad de todas las bases de datos PostgreSQL cada día a las 2:00 AM.

Módulo filesystem

El módulo filesystem se utiliza para crear o eliminar sistemas de archivos en dispositivos, particiones o volúmenes lógicos.

Soporta una variedad de sistemas de archivos, permitiendo la preparación de medios de almacenamiento para su uso.

- name: Crear un sistema de archivos ext4 en /dev/sdb1
  filesystem:
    fstype: ext4
    dev: /dev/sdb1

Este ejemplo formatea la partición /dev/sdb1 con el sistema de archivos ext4.

Módulo firewalld

El módulo firewalld es utilizado para gestionar las reglas del firewall utilizando Firewalld en sistemas Linux.

Permite añadir o eliminar reglas de firewall, servicios o zonas de forma dinámica sin necesidad de reiniciar el servicio.

- name: Abrir el puerto 80/tcp en el firewall
  firewalld:
    port: 80/tcp
    permanent: yes
    state: enabled

Este ejemplo habilita el acceso al puerto 80/tcp permanentemente en el firewall.

Módulo hostname

El módulo hostname permite a los administradores de sistemas gestionar el nombre del host de un sistema.

Es crucial para la configuración de red y la identificación del sistema en una red.

- name: Establecer el nombre del host
  hostname:
    name: mi-servidor

Este comando configura el nombre del host del sistema a mi-servidor.

Módulo mount

El módulo mount se encarga de montar y desmontar sistemas de archivos en sistemas Linux/Unix.

Gestiona el montaje de dispositivos, particiones, o volúmenes lógicos, y asegura que estén montados o desmontados según se desee.

- name: Montar /dev/sdb1 en /mnt/data
  mount:
    path: /mnt/data
    src: /dev/sdb1
    fstype: ext4
    state: mounted

Este ejemplo asegura que /dev/sdb1 esté montado en /mnt/data.

Módulo user

El módulo user permite la gestión de usuarios en sistemas Unix/Linux.

Ofrece una forma sencilla de agregar, modificar, o eliminar cuentas de usuario, junto con sus propiedades.

- name: Añadir un usuario
  user:
    name: nuevo_usuario
    comment: "Usuario Ejemplo"
    shell: /bin/bash

Este ejemplo crea un usuario llamado nuevo_usuario con acceso a bash como su shell.

Módulo group

El módulo group de Ansible se utiliza para gestionar grupos en sistemas Unix/Linux.

Permite crear, eliminar o modificar grupos en el sistema, facilitando la administración de permisos y el acceso a recursos compartidos entre usuarios.

- name: Añadir un grupo
  group:
    name: mi_grupo
    state: present
]]>
<![CDATA[ Instalar Hacs en Home Assistant ]]> https://voidnull.es/instalar-hacs-en-home-assistant/ 65def668add21a0cbc9777aa Thu, 21 Mar 2024 10:42:27 +0100 HACS (Home Assistant Community Store) es una extensión para Home Assistant, una plataforma de automatización del hogar de código abierto.

HACS proporciona una interfaz de usuario conveniente para descubrir, instalar y gestionar componentes personalizados, como integraciones, plugins, temas y scripts de automatización que no están incluidos en la instalación estándar de Home Assistant.

Esto permite a los usuarios de Home Assistant personalizar y ampliar la funcionalidad de sus sistemas de automatización del hogar con nuevas características y dispositivos que la comunidad de desarrolladores y aficionados ha creado.

Pasos previos para su instalación

Antes de liarnos a la instalación y configuración, tenemos que activar unas cosas para que funcione todo correctamente.

Activar el modo avanzado

Lo primero es activar el modo avanzado de Home Assistant. Para ello es tenemos que hacer clic sobre nuestro usuario y activar la opción Modo Avanzado.

Instalar un complemento: Web Terminal

Hay que ir a Configuración - Complementos y en el botón Directorio de Complementos, tenemos que buscar un complemento llamado Advanced SSH & Web Terminal:

Tendremos que darle a instalar y una vez esté instalado tenemos que ir a la pestaña Configuración y añadir nuestro usuario y contraseña.

username: [usuario]
password: [contraseña]
💡
Puede ser tu usuario de Home Assistant, o puedes poner un usuario o contraseña diferente. Lo importante es definir estos dos parámetros ya que sin ellos no se puede iniciar el complemento.

Le damos a Guardar y volvemos a la pestaña Información e iniciamos el componente. Una vez se haya iniciado, podremos acceder a la interfaz de la terminal:

Instalación de Hacs

Ahora para instalar Hacs en Home Assistant, tenemos que ejecutar el siguiente comando:

wget -O - https://get.hacs.xyz | bash -

El resultado de ejecutar el script, es similar a la imagen de aquí abajo:

Una vez se haya ejecutado, tendremos que reiniciar Home Assistant, para ello iremos a Herramientas para desarrolladores y haremos clic sobre el botón Reiniciar:

Añadir integración

Una vez hemos reiniciado nuestro Home Assistant, tenemos que ir a Configuración - Dispositivos y Servicios y hacemos clic sobre el botón Añadir Integración. En la ventana tendremos que buscar Hacs:

Hacemos clic sobre el icono de Hacs e iniciamos su configuración:

Tenemos que marcar todas las opciones y darle a Enviar.

Ahora tendremos que acceder a la URL que nos indica y entrar con nuestra cuenta de Github y validar la cuenta con el código que nos proporcionan.

💡
Si no tienes cuenta de GitHub, deberás de hacer el registro previamente.

Una vez se haya finalizado la configuración de Hacs con Home Assistant, nos aparecerá en el lateral un botón nuevo para acceder a Hacs:

Si pulsamos sobre este nuevo elemento en el menú lateral, podremos ver todos los complementos disponibles para instalar:

Ahora ya podemos buscar nuestro complemento e instalarlo con un solo clic.

]]>
<![CDATA[ Añadir un disco duro en TrueNAS ]]> https://voidnull.es/anadir-un-disco-duro-en/ 65e8b582add21a0cbc97804b Wed, 20 Mar 2024 10:46:28 +0100 En este tutorial sobre TrueNAS aprenderemos a gestionar los discos duros, aprenderemos a añadir un disco duro a TrueNAS y configurar el disco para luego crear pools. Esto es necesario para luego utilizar esas Pools dentro del disco para compartir diferentes directorios utilizando NFS o SMB.

Si estás usando TrueNAS utilizando Proxmox, este artículo te puede ser útil para saber como añadir un disco extraíble en una máquina virtual:

Añadir un disco a una maquina virtual en Proxmox
En este tutorial explicaremos como conectar ese disco extraíble a nuestro servidor con Proxmox para compartirlo directamente con una máquina virtual concreta.

Configurar disco en TrueNAS

Lo primero será ir a Storage - Disks, donde podremos ver los discos que tenemos:

Para este tutorial, configuraremos el disco con nombre da2. Para ello desplegaremos el menú del disco (en la flecha de la derecha):

Aquí podemos editar el disco o bien podemos hacer un WIPE, que básicamente sería eliminar todo el contenido y formartearlo. Pulsaremos en WIPE:

Tenemos diferentes métodos para eliminar el disco, en este tutorial utilizaremos el método Quick que es el método rápido. Confirmamos y le damos a Continuar:

E iniciará el proceso:

Una vez finalice, que no debería de tardar mucho, nos aparecerá lo siguiente:

Añadir disco en Pool

Ahora configuraremos el disco para añadirlo a una pool y así poder crear los diferentes directorios para compartir por NFS o SMB.

Tenemos que ir a Storage - Pools y añadir una nueva Pool haciendo clic en el botón de Add:

Seleccionamos Create new pool para crear una nueva pool y hacemos clic sobre Create Pool.

Aquí tenemos que seleccionar un nombre, para este tutorial le hemos puesto de nombre DiscoCompartido:

Podemos seleccionar la opción de Encryption para cifrar el disco. Todo dependerá un poco de lo que necesitéis guardar en el disco. Luego tendremos un listado de discos disponibles para añadir a la Pool.

Seleccionaremos el disco da2 y lo moveremos al apartado Data VDevs:

Marcaremos la opción Force y luego Confirm:

Finalmente, hacemos clic sobre el botón Create para iniciar la pool:

Marcamos de nuevo Confirm y Create Pool:

Cuando finalice se nos mostrará la pool con el disco:

A partir de ahora, ya tendremos el disco preparado para compartir directorios por SMB o NFS o hacer cualquier otra cosa.

]]>
<![CDATA[ Actualizar Grafana a la última versión disponible ]]> https://voidnull.es/actualizar-grafana-a-la-ultima-version-disponible/ 65e9ab9eadd21a0cbc9780fc Tue, 19 Mar 2024 10:42:39 +0100 Recientemente se ha liberado una versión nueva de Grafana, la 10.4 y aprovechando este momento vamos a ver como actualizar Grafana a su última versión.

Actualmente el Grafana que utilizo tiene la versión v9.5.0, dependiendo la versión que tengáis, disponéis de documentación oficial para actualizar de una versión a la otra.

A continuación vamos a ver como actualizar a la versión 10.4, dependiendo de como tengáis la instalación, si es por repositorio o ejecutable se tendrá que hacer de una forma u otra.

Actualizar Grafana a la versión 10.4

Nos descargaremos la versión OSS de Grafana en formato .deb con el siguiente comando:

wget https://dl.grafana.com/oss/release/grafana_10.4.0_amd64.deb

E instalamos el paquete:

dpkg -i grafana_10.4.0_amd64.deb

Si habéis instalado Grafana usando el repositorio, podéis ejecutar lo siguiente:

apt update
apt upgrade

Actualizar plugins de Grafana

Es posible que tengamos que actualizar también los plugins, podemos hacerlo utilizando comandos también:

grafana-cli plugins update-all

Salida del comando

Updating alexanderzobnin-zabbix-app Removing plugin: alexanderzobnin-zabbix-app ✔ Downloaded and extracted alexanderzobnin-zabbix-app v4.4.6 zip successfully to /var/lib/grafana/plugins/alexanderzobnin-zabbix-app

Updating marcusolsson-json-datasource Removing plugin: marcusolsson-json-datasource ✔ Downloaded and extracted marcusolsson-json-datasource v1.3.12 zip successfully to /var/lib/grafana/plugins/marcusolsson-json-datasource

Please restart Grafana after installing or removing plugins. Refer to Grafana documentation for instructions if necessary.

Y reiniciamos el servicio para recargar Grafana:

systemctl restart grafana-server.service 

Con todo esto tendremos Grafana en la última versión y con las nuevas características listas para ser utilizadas.

]]>
<![CDATA[ Crear un backup de una maquina y excluir un disco en Proxmox ]]> https://voidnull.es/crear-un-backup-de-una-maquina-y-excluir-un-disco-en-proxmox/ 65e22e5eadd21a0cbc977b85 Mon, 18 Mar 2024 10:29:39 +0100 A veces necesitaremos excluir un disco duro extra que hemos conectado al Proxmox para que no haga backup de ese disco. Ya sea porque el disco es más grande que el espacio que tenemos para backups o porque simplemente no queremos hacer copia de ese disco.

Por ejemplo, tengo añadido un disco duro externo a una maquina de TrueNAS para crear los directorios para compartir por NFS diferentes directorios y cuando hacía backup de las máquinas virtuales, me daba error porque en el backup incluía el disco externo de 6TB y no había espacio suficiente, por lo que siempre daba error el backup.

Para evitar esto, lo que podemos hacer, es excluir el disco de la copia. En el siguiente tutorial te explico como hacer esto, que la verdad es una cosa muy sencilla.

Excluir disco en una copia de seguridad

Si queremos excluir el disco, tenemos que seleccionar nuestra máquina e ir al apartado de Hardware. Allí seleccionar el disco que queremos excluir y editarlo.

En la edición, tenemos que desmarcar la opción de Backup:

Guardamos los cambios haciendo clic en Ok y listo, en el próximo backup únicamente hará copia de la maquina y del disco donde tenemos instalado lo que sea y excluirá ese disco.

Hacer el mismo proceso por línea de comandos

Este proceso también se puede hacer usando el CLI si no queremos hacerlo gráficamente. Para ello tendremos que editar el fichero de configuración de la maquina que se encuentra en /etc/pve/qemu-server y editar el fichero con el ID de la maquina.

Dentro de la configuración, veremos la configuración para el segundo disco:

scsi1: /dev/disk/by-id/ata-WDC_WD50NDZW-11A8JS0_WD-WX52D812X9A7,serial=WX52D812X9A7,size=4769275M

Deberemos de incluir la opción backup=0 para excluirlo del backup:

scsi1: /dev/disk/by-id/ata-WDC_WD50NDZW-11A8JS0_WD-WX52D812X9A7,backup=0,serial=WX52D812X9A7,size=4769275M

Y guardar cambios.

Conclusión

De esta manera hemos excluido un disco duro para que no haga un backup y únicamente tengamos la copia de la maquina.

]]>
<![CDATA[ Configurar avisos SMTP por Proxmox ]]> https://voidnull.es/configurar-avisos-smtp-por-proxmox/ 65de3495add21a0cbc97771b Fri, 15 Mar 2024 10:26:12 +0100 Proxmox VE, una plataforma líder de virtualización de código abierto, ofrece una solución robusta para ejecutar máquinas virtuales y contenedores, pero para aprovechar al máximo sus capacidades, es esencial tener configurado un sistema de notificación confiable.

En este artículo, exploraremos cómo configurar el servidor SMTP en Proxmox VE, lo que te permitirá enviar correos electrónicos de notificación desde tu sistema Proxmox.

Configurar cuenta de correo

Para configurar la cuenta de correo y así recibir las alertas y avisos de Proxmox, deberemos de ir a Datacenter - Options - Email from address. Editaremos el campo y configuraremos nuestra cuenta de correo:

Configurar servidor SMPT

Por defecto Proxmox 8.x ya viene con el SMTP configurado con SendMail. Si vamos a Datacenter - Notifications podemos revisar que hay la configuración de SendMail para el usuario root:

Podemos añadir una configuración nueva para SMTP en Add - SMTP y rellenar todos los datos:

Configurar avisos para los backups

Para recibir un aviso cuando se ejecute un backup, deberemos de ir a Datacenter - Backup y seleccionaremos nuestra copia de seguridad para editarla.

Tendremos que configurar los siguientes valores de la captura de más arriba:

  • Notification Mode: Aquí podremos seleccionar el modo de notificación. Para que use la opción de e-mail seleccionaremos Email.
  • Send email: Aquí podemos seleccionar dos opciones Always, para recibir el e-mail siempre o On failure only, para recibir el aviso solo cuando el backup falle.
  • Send email to: Aquí escribiremos la cuenta de correo donde recibir los avisos.

Guardaremos la configuración y ahora cuando se ejecute el backup recibiremos un e-mail con la siguiente información:

]]>
<![CDATA[ Primeros pasos en Home Assistant ]]> https://voidnull.es/primeros-pasos-en-home-assistant/ 65de3519add21a0cbc977735 Thu, 14 Mar 2024 10:51:42 +0100 Home Assistant es un software de automatización del hogar de código abierto que permite a los usuarios conectar y gestionar una amplia variedad de dispositivos inteligentes desde una única plataforma centralizada. Diseñado para ser privado, seguro y totalmente personalizable, Home Assistant se ejecuta localmente, lo que significa que todos los datos permanecen en la casa del usuario y no se comparten con terceros a menos que el usuario decida hacerlo.

Primera configuración tras la instalación

La primera vez que accedamos al Home Assistant, deberemos de introducir la IP del servidor acompañado del puerto 8123.

Nos cargará lo siguiente:

Haremos clic sobre Crear mi Hogar Inteligente si queremos empezar de cero, también podemos importar una copia de seguridad.

En este caso iniciaremos un Home Assistant desde cero, por lo que haremos clic sobre el botón. Creamos nuestro usuario de acceso:

Seleccionamos la ubicación de nuestro hogar:

Si queremos colaborar de forma anónima para reportar errores y problemas, podemos activar las opciones.

Home Assistant automáticamente encontrará dispositivos en tu red local.

Una vez hagamos clic en Terminal nos cargará el tablero para configurar las tarjetas en él:

]]>
<![CDATA[ touch: mucho más que crear ficheros ]]> https://voidnull.es/touch-mucho-mas-que-crear-ficheros/ 65e8aa4badd21a0cbc977fde Wed, 13 Mar 2024 10:01:43 +0100 El comando touch es una herramienta esencial en sistemas operativos basados en Unix, como GNU/Linux. Se utiliza principalmente para crear archivos vacíos o para cambiar las marcas de tiempo (fecha y hora de acceso o modificación) de un archivo existente sin modificar su contenido.

Utilidad del comando touch

A continuación, se presenta una descripción detallada de su utilidad, sintaxis básica y algunas opciones importantes, acompañadas de ejemplos prácticos.

Creación de archivos vacíos

Es una forma rápida y eficiente de crear un nuevo archivo sin contenido. Esto es útil para, por ejemplo, iniciar un nuevo script o documento antes de editarlo con un editor de texto.

Actualización de marcas de tiempo

touch permite actualizar las fechas de acceso y modificación de los archivos a la fecha y hora actuales. Esto puede ser útil para scripts que dependen de las fechas de los archivos para su lógica de procesamiento o para simplemente actualizar un archivo para que aparezca como recientemente modificado.

Sintaxis básica

La sintaxis básica del comando touch es la siguiente:

touch [OPCIONES] ARCHIVO...
  • [OPCIONES]: Modificadores que alteran el comportamiento del comando.
  • ARCHIVO...: Lista de uno o más archivos a crear o modificar.

Opciones interesantes del comando

A continuación pasamos a detallar algunas opciones interesantes del comando.

Crear un archivo vacío

Para crear un archivo vacío llamado documento.txt, simplemente ejecuta:

touch documento.txt

Actualizar la marca de tiempo de un archivo existente

Para actualizar las fechas de acceso y modificación de documento.txt a la fecha y hora actuales, usa:

touch documento.txt

Actualizar solo la marca de tiempo de modificación

Si solo quieres actualizar la marca de tiempo de modificación de documento.txt, puedes usar:

touch -m documento.txt

Actualizar marcas de tiempo de un fichero sin crearlo

Para intentar actualizar las marcas de tiempo de un archivo sin crearlo si no existe, puedes usar:

touch -c posible_documento.txt

Establecer una marca de tiempo específica

Para establecer una fecha y hora específicas en las marcas de tiempo de documento.txt, por ejemplo, el 1 de enero de 2023 a las 12:00 horas, puedes utilizar:

touch -t 202301011200 documento.txt

Estos ejemplos muestran la versatilidad del comando touch para la gestión de archivos en sistemas Unix-like. Es una herramienta simple pero poderosa para el manejo de archivos y directorios, útil tanto para usuarios novatos como avanzados.


¿Buscas otro comando?

¡Revisa nuestro "Diccionario de comandos para GNU/Linux"!

Diccionario de comandos para GNU/Linux

]]>
<![CDATA[ Accede a tus servidores usando la VPN de Tailscale ]]> https://voidnull.es/accede-a-tus-servidores-usando-la-vpn-de-tailscale/ 65dca06dadd21a0cbc9775ae Tue, 12 Mar 2024 10:22:40 +0100 Tailscale es una red privada virtual (VPN) que facilita la conexión segura de dispositivos y redes a través de Internet. Utiliza la tecnología WireGuard, conocida por su velocidad y seguridad, para crear una red mesh entre tus dispositivos. Esto significa que cada dispositivo en la red Tailscale puede conectarse directamente a otro, sin necesidad de pasar por servidores centrales, lo que mejora la velocidad y reduce la latencia.

La configuración de Tailscale es notablemente sencilla en comparación con las VPNs tradicionales. No requiere de una configuración manual compleja ni de hardware especializado; basta con instalar la aplicación en los dispositivos que deseas conectar y seguir unos simples pasos para tener tu red privada funcionando. Esto lo hace accesible para usuarios no técnicos, así como una solución práctica para profesionales de TI que buscan simplificar la gestión de sus redes.

Configuración cuenta Tailscale

Lo primero será configurar una cuenta de Tailscale, para ello deberemos de ir a la web oficial y registrar una cuenta nueva.

Una vez dentro de nuestra cuenta veremos lo siguiente:

Configuración servidor

Si lo que queremos es configurar un servidor para acceder a través de Tailscale, entonces deberemos de acceder por SSH al servidor y ejecutar lo siguiente:

curl -fsSL https://tailscale.com/install.sh | sh

Esto añadirá un repositorio y configurará los paquetes necesarios para que Tailscale funcione correctamente en nuestro servidor.

Para iniciar Tailscale, deberemos de ejecutar:

tailscale up

Este comando nos mostrará un enlace:

To authenticate, visit:

        https://login.tailscale.com/a/XXXXXXXXXXX

Lo copiamos y entramos usando nuestro navegador. Deberemos de iniciar sesión a nuestra cuenta de Tailscale y luego podremos añadir el dispositivo:

Hacemos clic sobre el botón Connect y se añadirá el dispositivo. Ahora si volvemos a la página del inicio, veremos que aparece un dispositivo en nuestra red:

Conectar nuestro cliente

Ahora lo que debemos de hacer es conectar nuestro ordenador con el que solemos acceder a nuestros servidores. Por ejemplo, si es un GNU/Linux, deberemos de ejecutar el mismo procedimiento para añadir el segundo dispositivo.

Cuando tengamos nuestro segundo dispositivo conectado, tendremos acceso a un panel completo de Tailscale donde podremos configurar muchas cosas:

Conectarnos por SSH al servidor

Ahora desde nuestro dispositivo conectado a Tailscale, que es el que he llamado Desktop, probaremos de conectarnos por SSH utilizando la IP asignada por Tailscale.

Lo primero es comprobar que podemos hacer ping al nombre de la maquina que hemos asignado:

# ping servidor-web
PING servidor-web.tailc3de0.ts.net (XX.XX.XX.XX) 56(84) bytes of data.
64 bytes from servidor-web.tailc3de0.ts.net (XX.XX.XX.XX): icmp_seq=1 ttl=64 time=28.6 ms
64 bytes from servidor-web.tailc3de0.ts.net (XX.XX.XX.XX): icmp_seq=2 ttl=64 time=1.42 ms
^C
--- servidor-web.tailc3de0.ts.net ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1002ms
rtt min/avg/max/mdev = 1.424/15.022/28.621/13.598 ms

Ahora podemos filtrar el puerto del SSH de nuestro servidor desde el Firewall para que solo se pueda acceder desde el rango configurado en Tailscale y acceder usando la IP o el nombre del servidor en Tailscale:

# ssh root@servidor-web
The authenticity of host 'servidor-web (XX.XX.XX.XX)' can't be established.
ED25519 key fingerprint is SXXXXXXXXXXXXX
This key is not known by any other names.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

Y listo, ya tenemos acceso a nuestro servidor desde los dispositivos conectados a Tailscale y de forma segura.

]]>
<![CDATA[ Instalar Invidious en Ubuntu 22.04 ]]> https://voidnull.es/instalar-invidious-en-ubuntu-22-04/ 65e0b299add21a0cbc977ac6 Mon, 11 Mar 2024 10:51:37 +0100 Invidious se describe a sí mismo como un front-end alternativo de Software Libre para YouTube. En términos básicos, esto significa acceder a YouTube a través de una interfaz diferente en un dominio diferente que elimina la publicidad, el seguimiento de los usuarios y la dependencia de las suscripciones de Google.

Como hemos mencionado anteriormente, está licenciado bajo AGPL-3.0 y Invidious puede ser autoalojado en servidores personales. Se puede montar con Docker pero también se puede hacer una instalación manual.

Recientemente Invidious está metida en "problemas" ya que YouTube ha enviado una notificación al autor del Software indicando que debe de "apagar" Invidious en 7 días. Está claro que Google no sabe muy bien como funciona el mundo del Software Libre, así que os vamos a explicar como configurar e instalar una instancia de Invidious.

Requisitos de Hardware

Para que funcione correctamente únicamente necesita 512MB de RAM. Para instancias públicas es recomendable un mínimo de 4GB de RAM, 2vCPU y 200mbps de ancho de banda y un mínimo de 20TB de tráfico.

Instalación de Invidious

Lo primero será instalar todo lo necesario para que funcione correctamente, así que lo primero será instalar dependencias que necesitaremos:

apt install libssl-dev libxml2-dev libyaml-dev libgmp-dev libreadline-dev postgresql librsvg2-bin libsqlite3-dev zlib1g-dev libpcre3-dev libevent-dev git make

Instalación de Crystal

Para utilizar Invidious es necesario instalar Crystal, para ello realizaremos lo siguiente:

curl -fsSL https://crystal-lang.org/install.sh | sudo bash -s -- --channel=nightly

Creamos usuario y clonamos repositorio

Creamos usuario para gestionar el programa en el sistema:

useradd -m invidious

Accedemos al usuario y clonamos repositorio:

su - invidious
git clone https://github.com/iv-org/invidious
exit

Configuramos PostgreSQL

Iniciamos el servicio de PostgreSQL:

systemctl enable --now postgresql

Y creamos el usuario y la base de datos:

sudo -i -u postgres
psql -c "CREATE USER kemal WITH PASSWORD 'supercontraseña';"
createdb -O kemal invidious
exit

Configuramos Invidious

Lo primero será acceder al usuario y entrar al directorio del repositorio:

su - invidious
cd invidious

Y compilamos:

make

Creamos el fichero de configuración:

cp config/config.example.yml config/config.yml 

Y hacemos la migración de la base de datos:

./invidious --migrate
crystal build src/invidious.cr -Ddisable_quic --release
exit

Configuración de SystemD

Configuramos ahora SystemD, primero copiamos el fichero que corresponde:

cp /home/invidious/invidious/invidious.service /etc/systemd/system/invidious.service

Y lo habilitamos:

systemctl enable --now invidious.service

Ahora tendremos el servicio escuchando por el puerto 3000. Lo siguiente será configurar un Proxy Inverso con Nginx.

Configurar Proxy Inverso con Nginx

Lo siguiente será configurar un Proxy Inverso para acceder con dominio a nuestra instancia de Invidious. Para ello deberemos de seguir estos pasos:

Configurar Proxy Inverso con Nginx para que escuche a un puerto interno
En ocasiones tenemos servicios o aplicaciones web que escuchan directamente a un puerto interno. Para evitar acceder a dicha aplicación o servicio por la IP del servidor, una configuración que podemos hacer es acceder desde un Nginx Proxy.
💡
Para este caso deberemos de configurar el Proxy Inverso con Nginx utilizando el puerto 3000.

Para más configuración podéis revisar la documentación oficial de Invidious.

]]>
<![CDATA[ Utiliza Helper-Scripts para desplegar contenedores y máquinas virtuales de casi cualquier cosa ]]> https://voidnull.es/utiliza-helper-scripts-para-desplegar-contenedores-y-maquinas-virtuales-de-casi-cualquier-cosa/ 65e606eaadd21a0cbc977d5e Sat, 09 Mar 2024 10:29:32 +0100 Los Helper-Scripts para Proxmox son scripts o programas de utilidad diseñados para facilitar o automatizar ciertas tareas de administración y configuración en sistemas que utilizan Proxmox VE (Virtual Environment), una plataforma de virtualización de código abierto. Estos scripts pueden variar en complejidad y propósito, desde automatizar la instalación de software adicional, configurar ajustes de red, hasta realizar copias de seguridad y restauraciones de manera más eficiente.

En general, el propósito de los Helper-Scripts es simplificar la gestión de entornos virtuales, reducir el tiempo de configuración manual y minimizar el potencial de errores humanos. Algunos ejemplos incluyen scripts para:

  • Automatizar la creación y gestión de máquinas virtuales (VMs) y contenedores.
  • Configurar redes virtuales o ajustar la seguridad del sistema.
  • Realizar tareas de mantenimiento, como actualizaciones automáticas o limpieza de recursos no utilizados.
  • Implementar soluciones de respaldo y recuperación.

Estos scripts suelen estar escritos en lenguajes de scripting como Bash, Python o Perl, y pueden ser creados por la comunidad de usuarios de Proxmox VE o por el equipo de Proxmox, dependiendo de su complejidad y uso específico. Utilizar estos scripts puede ser una manera eficaz de optimizar y personalizar el entorno de Proxmox VE para satisfacer las necesidades específicas de un proyecto o infraestructura.

En muchos de los tutoriales que haremos en voidNull utilizaremos concretamente estos Helper-Scripts:

Proxmox VE Helper-Scripts | Scripts for Streamlining Your Homelab with Proxmox VE
Scripts for Streamlining Your Homelab with Proxmox VE

¿Como se usan?

La utilización de estos scripts son muy sencillos, lo primero es seleccionar el script que queremos usar, para hacer este tutorial utilizaremos el script para instalar Debian 12:

En cada script hay un comando para descargar un script en bash y ejecutarlo directamente. En este script hay toda la información necesaria para desplegar un contenedor o maquina virtual:

Fragmento del script donde se despliega la maquina virtual

Para ejecutar este comando debemos de ir a Datacenter - Nombre de nuestro nodo - Shell. Se nos abrirá una consola donde poder ejecutar el comando:

Tras ejecutarlo, nos pedirá una serie de información, podemos seleccionar la configuración por defecto o podemos configurarlo nosotros. Tras rellenar todas las opciones se iniciará la instalación de la máquina virtual.

]]>
<![CDATA[ Módulos: Bases de datos [Ansible #19] ]]> https://voidnull.es/modulos-bases-de-datos/ 659fd23015109503e5ec5a04 Fri, 08 Mar 2024 10:02:41 +0100 Ansible es una herramienta de automatización poderosa que permite a los usuarios gestionar y configurar sistemas, desplegar software y orquestar tareas más complejas como el despliegue continuo. Una de las áreas donde Ansible brilla es en la gestión de bases de datos, gracias a una variedad de módulos específicos para cada sistema de gestión de bases de datos.

En este artículo, exploraremos los módulos mysql_db, mysql_user, postgresql_db, postgresql_user, y mongodb_user, proporcionando una descripción y ejemplos de código para entender su funcionamiento.

Módulo mysql_db

El módulo mysql_db de Ansible se utiliza para crear, eliminar y gestionar bases de datos en un servidor MySQL o MariaDB.

Permite al usuario automatizar la administración de bases de datos en sistemas que usan MySQL o MariaDB, soportando operaciones como la creación, eliminación, y volcado de bases de datos.

- name: Crear una base de datos en MySQL
  mysql_db:
    name: mi_base_de_datos
    state: present
    login_user: root
    login_password: mi_contraseña_root

Este ejemplo crea una base de datos llamada mi_base_de_datos en un servidor MySQL/MariaDB.

Módulo mysql_user

El módulo mysql_user de Ansible se utiliza para gestionar usuarios y privilegios en un servidor MySQL o MariaDB.

Facilita la creación, modificación, y eliminación de usuarios en MySQL o MariaDB, permitiendo también gestionar los privilegios de estos usuarios.

- name: Crear un usuario en MySQL
  mysql_user:
    name: mi_usuario
    password: mi_contraseña
    priv: '*.*:ALL'
    state: present
    login_user: root
    login_password: mi_contraseña_root

Este ejemplo crea un usuario mi_usuario con todos los privilegios sobre todas las bases de datos y tablas.

Módulo postgresql_db

El módulo postgresql_db se utiliza para crear, eliminar y gestionar bases de datos en un servidor PostgreSQL.

Proporciona una manera de automatizar la administración de bases de datos en PostgreSQL, incluyendo la creación, eliminación, y modificación de bases de datos.

- name: Crear una base de datos en PostgreSQL
  postgresql_db:
    name: mi_base_de_datos
    state: present
    login_user: postgres
    login_password: mi_contraseña_postgres

Este ejemplo demuestra cómo crear una base de datos mi_base_de_datos en PostgreSQL.

Módulo postgresql_user

El módulo postgresql_user se utiliza para gestionar usuarios y privilegios en un servidor PostgreSQL.

Ayuda en la creación, modificación, y eliminación de usuarios en PostgreSQL, además de permitir la gestión de los privilegios de estos usuarios.

- name: Crear un usuario en PostgreSQL
  postgresql_user:
    name: mi_usuario
    password: mi_contraseña
    state: present
    login_user: postgres
    login_password: mi_contraseña_postgres

Este ejemplo crea un usuario mi_usuario en PostgreSQL.

Módulo mongodb_user

El módulo mongodb_user se utiliza para gestionar usuarios en una instancia MongoDB.

Permite crear, eliminar y gestionar usuarios en MongoDB, ofreciendo control sobre los roles y privilegios asignados a cada usuario.

- name: Crear un usuario en MongoDB
  mongodb_user:
    database: admin
    name: mi_usuario
    password: mi_contraseña
    roles: 
      - dbAdmin
      - userAdmin
    state: present

Este ejemplo demuestra cómo crear un usuario mi_usuario con roles dbAdmin y userAdmin en la base de datos admin de MongoDB.

Estos módulos de Ansible ofrecen una manera eficiente y automatizada de gestionar diferentes aspectos de las bases de datos, lo que puede simplificar significativamente las operaciones de TI y garantizar una gestión coherente y segura de las bases de datos en diferentes entornos.

]]>
<![CDATA[ xkill: mata procesos a golpe de clic ]]> https://voidnull.es/xkill-mata-procesos-a-golpe-de-clic/ 65e0543dadd21a0cbc9779b4 Thu, 07 Mar 2024 10:13:56 +0100 El comando xkill es una herramienta esencial en el entorno de escritorio GNU/Linux que permite a los usuarios finalizar tareas o aplicaciones que no responden sin necesidad de reiniciar el sistema completo. Es particularmente útil cuando una aplicación gráfica se congela, se bloquea o de otra manera deja de responder a las entradas del usuario.

Funcionamiento de xkill

Cuando se ejecuta, xkill transforma el cursor del ratón en una calavera o en un símbolo de "X" (dependiendo de la configuración y el entorno de escritorio), indicando que el usuario puede ahora hacer clic en cualquier ventana para terminar forzosamente el proceso asociado a esa ventana. Es una herramienta poderosa, ya que no requiere que el usuario conozca el ID del proceso (PID) de la aplicación que desea terminar; basta con hacer clic en la ventana.

Una vez que el usuario hace clic en una ventana, xkill envía una señal de SIGKILL al proceso asociado con esa ventana, lo que resulta en la terminación inmediata del proceso. Es importante tener en cuenta que xkill no realiza un cierre limpio del proceso, lo que significa que cualquier dato no guardado se perderá.

Opciones destacadas

Aunque xkill es un comando relativamente simple, tiene algunas opciones que pueden ser útiles:

  • -display displayname: Especifica la pantalla a la cual xkill debería conectarse. Útil en configuraciones donde múltiples pantallas o sesiones X están activas.
  • -id resource: Permite al usuario especificar el recurso o ventana a cerrar mediante su ID, en lugar de hacer clic en ella. Esto puede ser útil para scripts o cuando se sabe el ID de la ventana específica.
  • -button number: Permite al usuario especificar qué botón del ratón debe ser usado para seleccionar la ventana a terminar. Por defecto, cualquier botón puede ser utilizado.
  • -frame: Esta opción fuerza a xkill a terminar el proceso asociado con el marco de la ventana, no solo la ventana cliente.

Ejemplos de uso

A continuación os mostramos algunos ejemplos del comando.

Uso con un ID específico de ventana

Si por alguna razón necesita cerrar una ventana específica utilizando su ID, primero debe obtener el ID de la ventana (usando herramientas como xwininfo), y luego puede usar xkill de la siguiente manera:

xkill -id ventana_id

Donde ventana_id es el ID de la ventana que desea cerrar.

Configuración del botón del ratón

Si desea configurar xkill para usar un botón específico del ratón para seleccionar la ventana a cerrar, puede hacerlo de la siguiente manera:

xkill -button 1

Esto configurará xkill para usar solo el botón izquierdo del ratón (botón 1) para seleccionar la ventana.

En resumen, xkill es una herramienta indispensable para los usuarios de GNU/Linux que proporciona una manera rápida y eficiente de manejar aplicaciones que no responden. Su simplicidad y potencia lo convierten en una opción valiosa para la gestión de ventanas en el entorno de escritorio de GNU/Linux.

]]>
<![CDATA[ Configurar cuenta de correo para las notificaciones en TrueNAS ]]> https://voidnull.es/configurar-cuenta-de-correo-para-las-notificaciones-en-truenas/ 65de4281add21a0cbc97777c Wed, 06 Mar 2024 10:43:14 +0100 TrueNAS es una plataforma de almacenamiento de datos de código abierto que se basa en el sistema operativo FreeBSD y en el sistema de archivos ZFS (Z File System). Es el sucesor de FreeNAS, tras su rebranding y expansión por iXsystems, una compañía que ofrece soluciones de almacenamiento y servidores basados en software de código abierto. TrueNAS está diseñado para proporcionar almacenamiento en red (NAS, por sus siglas en inglés Network-Attached Storage) y almacenamiento unificado (SAN, por sus siglas en inglés Storage Area Network) con una alta fiabilidad, eficiencia en la gestión de datos, y robustas capacidades de protección de datos.

Configurar cuenta de correo

Primero configurar correo en la cuenta de root hay que ir a Accounts - Users y desplegar el usuario root:

Hacemos clic sobre el botón Edit y añadimos una cuenta de correo en el apartado de email. Guardamos cambios.

Luego tenemos que ir a System - Email y aquí tenemos que configurar la cuenta SMTP que nos enviará e-mails.

Tendremos que configurar el servidor SMTP, puerto y seguridad.

Le damos a Save para guardar los cambios y luego podemos hacer clic sobre Send Test Mail para hacer una prueba de envío. Si todo ha ido bien, obtendréis que siguiente aviso:

Y en el correo tendremos lo siguiente:

]]>
<![CDATA[ Instalación de Bitwarden utilizando Docker en Ubuntu 22.04 ]]> https://voidnull.es/instalacion-de-bitwarden-utilizando-docker-ubuntu-22-04/ 65d32453add21a0cbc977337 Tue, 05 Mar 2024 10:27:09 +0100 Bitwarden es un gestor de contraseñas de código abierto que proporciona una forma segura de almacenar y gestionar todas tus contraseñas y datos sensibles. Te permite crear, almacenar y acceder a tus contraseñas desde cualquier dispositivo, garantizando que todas ellas estén protegidas por un fuerte cifrado.

Con Bitwarden, puedes generar contraseñas seguras y únicas para cada uno de tus cuentas en línea, reduciendo el riesgo de hackeo y de compromiso de tus datos personales. Además de contraseñas, Bitwarden también permite guardar notas seguras, información de tarjetas de crédito y otros datos sensibles.

En el siguiente tutorial vamos a instalar la versión self-hosting en un servidor con Ubuntu 22.04 y Docker.

Especificaciones de Bitwarden

A continuación os pasamos la tabla siguiente con los recursos necesarios para este software:

Minimum Recommended
Processor x64, 1.4GHz x64, 2GHz dual core
Memory 2GB RAM 4GB RAM
Storage 12GB 25GB
Docker Version Engine 19+ and Compose 1.24+ Engine 19+ and Compose 1.24+

Requisitos para instalar Bitwarden

Para instalar Bitwarden correctamente es necesario tener configurado previamente lo siguiente:

  • Un dominio apuntando correctamente al servidor.
  • Tener instalado en el servidor Docker y Docker Compose

Para instalar Docker en Ubuntu 22.04, podéis seguir este otro tutorial:

Instalación de Docker en Ubuntu 22.04
Docker es una aplicación que simplifica el proceso de gestión de los procesos de las aplicaciones en contenedores. Los contenedores le permiten ejecutar sus aplicaciones en procesos aislados de recursos.

Instalación de Bitwarden

El procedimiento para instalar Bitwarden se debe de seguir de la siguiente forma. Lo primero nos conectaremos al servidor por SSH.

Creación de usuario

Para ejecutar Bitwarden deberemos de crear un usuario especifico para que ejecute el contenedor de Docker.

adduser bitwarden

Configuramos contraseña al usuario:

passwd bitwarden

Añadimos el usuario al grupo de Docker:

usermod -aG docker bitwarden

Creamos el directorio de la instalación:

mkdir /opt/bitwarden

Configuramos los permisos de los directorios:

chmod -R 700 /opt/bitwarden
chown -R bitwarden:bitwarden /opt/bitwarden

Instalación de Bitwarden

Ahora con el usuario de bitwarden ejecutamos los siguientes comandos para instalar Bitwarden:

$ curl -s -L -o bitwarden.sh "https://func.bitwarden.com/api/dl/?app=self-host&platform=linux"

Cambiamos permisos al ejecutable:

$ chmod +x bitwarden.sh

Y lo ejecutamos:

$ ./bitwarden.sh install

Se ejecutará el instalado y nos irá pidiendo información de nuestro servidor de Bitwarden, primero de todo nos pedirá el dominio:

(!) Enter the domain name for your Bitwarden instance (ex. bitwarden.example.com): dominio.com

Nos pide si queremos configurar SSL en el dominio, le decimos que si:

(!) Do you want to use Let's Encrypt to generate a free SSL certificate? (y/n): y

A continuación nos pedirá una ID de instalación que deberemos de ir a bitwarden.com/host y añadir nuestro dominio:

(!) Enter your installation id (get at https://bitwarden.com/host): 65001d80-9785-4a9b-978c-XXXXXXXX

Después de añadir esta información, finalizará la instalación y podremos levantar el contenedor de bitwarden:

$ ./bitwarden.sh start

Salida del comando

bitwarden.sh version 2024.2.0
Docker version 24.0.5, build 24.0.5-0ubuntu1~22.04.1
docker-compose version 1.29.2, build unknown

Pulling mssql ... done
Pulling web ... done
Pulling attachments ... done
Pulling api ... done
Pulling identity ... done
Pulling sso ... done
Pulling admin ... done
Pulling icons ... done
Pulling notifications ... done
Pulling events ... done
Pulling nginx ... done
Using default tag: latest
latest: Pulling from certbot/certbot
Digest: sha256:953b5daac63b14e4f8b77aacf4831f916faac836c67cd12fcc6408201554962e
Status: Image is up to date for certbot/certbot:latest
docker.io/certbot/certbot:latest
Saving debug log to /etc/letsencrypt/logs/letsencrypt.log

Processing /etc/letsencrypt/renewal/pass.arrels.top.conf

Certificate not yet due for renewal

The following certificates are not due for renewal yet:
/etc/letsencrypt/live/pass.arrels.top/fullchain.pem expires on 2024-05-19 (skipped)
No renewals were attempted.

Creating directory /root/bwdata/core
Creating directory /root/bwdata/core/attachments
Creating directory /root/bwdata/logs
Creating directory /root/bwdata/logs/admin
Creating directory /root/bwdata/logs/api
Creating directory /root/bwdata/logs/events
Creating directory /root/bwdata/logs/icons
Creating directory /root/bwdata/logs/identity
Creating directory /root/bwdata/logs/mssql
Creating directory /root/bwdata/logs/nginx
Creating directory /root/bwdata/logs/notifications
Creating directory /root/bwdata/logs/sso
Creating directory /root/bwdata/logs/portal
Creating directory /root/bwdata/mssql/backups
Creating directory /root/bwdata/mssql/data
Creating network "docker_default" with the default driver
Creating network "docker_public" with the default driver
Creating bitwarden-identity ... done
Creating bitwarden-icons ... done
Creating bitwarden-mssql ... done
Creating bitwarden-web ... done
Creating bitwarden-events ... done
Creating bitwarden-notifications ... done
Creating bitwarden-api ... done
Creating bitwarden-sso ... done
Creating bitwarden-attachments ... done
Creating bitwarden-admin ... done
Creating bitwarden-nginx ... done
2024.2.0: Pulling from bitwarden/setup
Digest: sha256:61accdd92a6b8819194610e4691cd0ee1da6c5b4ae58e63fc720da6135bf01da
Status: Image is up to date for bitwarden/setup:2024.2.0
docker.io/bitwarden/setup:2024.2.0

Bitwarden is up and running!

Ahora ya podemos acceder a nuestro dominio y crear una cuenta nueva. Como siempre si queréis configurar el servicio SMTP o configurar un administrador revisad la documentación oficial para más información.

]]>
<![CDATA[ Instala Pingvin Share en tu servidor para compartir ficheros ]]> https://voidnull.es/instala-pingvin-share-en-tu-servidor-para-compartir-ficheros/ 65de27dcadd21a0cbc9776ed Tue, 05 Mar 2024 10:19:00 +0100 Pingvin Share representa una solución innovadora en el ámbito del intercambio de archivos, ofreciendo una plataforma autoalojada que se erige como una alternativa directa a servicios populares como WeTransfer.

Esta plataforma se distingue por permitir a los usuarios establecer su propio servidor para compartir archivos, lo que proporciona un mayor control sobre la privacidad y seguridad de los datos compartidos.

A diferencia de otras opciones del mercado que dependen de servidores de terceros, Pingvin Share apuesta por una mayor autonomía y flexibilidad, brindando a individuos y organizaciones la capacidad de gestionar sus necesidades de intercambio de archivos de manera más personalizada y segura.

Requisitos para Pingvin Share

Para poder instalar Pingvin Share es necesario tener acceso SSH a tu servidor y tener instalado lo siguiente:

NodeJS

Esta aplicación está escrita en NodeJS y para ello necesitamos tener instalado NodeJS. Para instalar NodeJS en nuestro servidor deberemos de seguir este otro tutorial:

Instalación de NodeJS en GNU/Linux [Debian, Ubuntu, CentOS]
En el siguiente tutorial os explicaremos la correcta instalación de NodeJS en GNU/Linux. Ya sea tu servidor un Ubuntu o Debian o CentOS aquí encontrarás las instrucciones correctas para su instalación.

Git

Tendremos que descargar el repositorio desde Git, así que tendremos que tener instalado el siguiente paquete:

apt update git

PM2

Para tener la aplicación ejecutándose en segundo plano es necesario utilizar PM2. Recientemente hemos escrito un artículo sobre como instalarlo:

Instalación y configuración de PM2: gestiona tus aplicaciones NodeJS
PM2 (Process Manager 2) es una herramienta imprescindible en el arsenal de cualquier administrador de sistemas que trabaje con aplicaciones Node.js.

Instalación Pingvin Share

Para hacer la instalación, lo primeros será descargarnos el repositorio desde Github:

git clone https://github.com/stonith404/pingvin-share

Accedemos al directorio:

cd pingvin-share

Iniciar el backend

Primero tendremos que instalar la parte de backend, para hacerlo ejecutaremos los siguientes comandos:

cd backend
npm install
npm run build
pm2 start --name="pingvin-share-backend" npm -- run prod

Iniciar frontend

En segundo lugar, tendremos que instalar la parte de frontend, para hacerlo ejecutaremos los siguientes comandos:

cd ../frontend
npm install
npm run build
pm2 start --name="pingvin-share-frontend" npm -- run start

Configurar Nginx Proxy

Con la aplicación levantada ahora podemos configurar un Nginx Proxy para acceder a través de un dominio y con SSL.

Configurar Proxy Inverso con Nginx para que escuche a un puerto interno
En ocasiones tenemos servicios o aplicaciones web que escuchan directamente a un puerto interno. Para evitar acceder a dicha aplicación o servicio por la IP del servidor, una configuración que podemos hacer es acceder desde un Nginx Proxy.

Acceder a la aplicación

Una vez tenemos la configuración de Nginx, podemos acceder con nuestro navegador favorito:

Nos podremos registrar, ya que el primer registro se convertirá en el administrador del sitio y tendremos opción a gestionar toda la configuración de la aplicación.

]]>
<![CDATA[ Añadir un disco a una maquina virtual en Proxmox ]]> https://voidnull.es/anadir-un-disco-a-una-maquina-virtual-en-proxmox/ 65e0de54add21a0cbc977ad8 Mon, 04 Mar 2024 11:43:48 +0100 Imagina que tenemos un disco duro extraíble que queremos usar para compartir ficheros en nuestra red utilizando una maquina virtual con TrueNAS o cualquier otro software -o podría ser un Debian a pelo y con NFS configurado-.

En este tutorial explicaremos como conectar ese disco extraíble a nuestro servidor con Proxmox para compartirlo directamente con una máquina virtual concreta.

Identificar el disco

Lo primero que haremos será conectar el disco duro extraíble al servidor con Proxmox y luego identificar unos datos que tenemos que guardar para más tarde.

Para ello instalaremos el siguiente paquete para obtener los datos:

apt install lshw

Para mostrar los discos conectados a Proxmox:

lshw -class disk -class storage

Por ejemplo, mi disco duro extraíble:

*-disk
          description: SCSI Disk
          product: easystore 2648
          vendor: WD
          physical id: 0.0.0
          bus info: scsi@1:0.0.0
          logical name: /dev/sdb
          version: 1034
          serial: WX52D812X9A7
          size: 4657GiB (5TB)
          capabilities: gpt-1.00 partitioned partitioned:gpt
          configuration: ansiversion=6 guid=ad50bf1d-f042-403d-b96f-f3bb9072b868 logicalsectorsize=512 sectorsize=4096

De todos estos datos, el que nos interesa, será el serial, debemos de guardar este dato para usarlo más tarde.

Ahora mostramos los discos por ID y filtramos por nuestro serial:

# ls -al /dev/disk/by-id | grep WX52D812X9A7
lrwxrwxrwx 1 root root   9 Feb 29 20:13 ata-WDC_WD50NDZW-11A8JS0_WD-WX52D812X9A7 -> ../../sdb
lrwxrwxrwx 1 root root  10 Feb 29 20:13 ata-WDC_WD50NDZW-11A8JS0_WD-WX52D812X9A7-part1 -> ../../sdb1

Con este resultado, tenemos que guardar nuestro ID de disco, que es el que aparece y empieza por ata-WD.

Añadimos disco a la MV

💡
Antes de hacer este proceso, recuerda tener la maquina afectada apagada, ya que si está iniciada puede dar problemas.

Para añadir el disco necesitamos el ID de la MV, en mi caso es 102 y debemos de indicar el ID del disco con el siguiente comando:

# qm set 102 -scsi1 /dev/disk/by-id/ata-WDC_WD50NDZW-11A8JS0_WD-WX52D812X9A7 
update VM 102: -scsi1 /dev/disk/by-id/ata-WDC_WD50NDZW-11A8JS0_WD-WX52D812X9A7

Ahora si vamos a Datacenter - PVE y seleccionamos la maquina, si vamos al apartado de Hardware veremos que aparece un segundo disco:

Tenemos que editar el fichero de configuración de la maquina virtual para añadir el serial, para eso iremos a editar el fichero:

nano /etc/pve/qemu-server/[ID].conf

Y tendremos que añadir el serial a la configuración:

scsi1: /dev/disk/by-id/ata-WDC_WD50NDZW-11A8JS0_WD-WX52D812X9A7,size=4769275M

Añadimos serial=[serial]:

scsi1: /dev/disk/by-id/ata-WDC_WD50NDZW-11A8JS0_WD-WX52D812X9A7,size=4769275M,serial=WX52D812X9A7

Guardamos y ya podremos iniciar nuestra maquina y configurar el disco a nuestro gusto.

]]>
<![CDATA[ Newsletter #02/24 - Una de VPN, seguimos con Ansible y comandos y añadimos artículos sobre Proxmox ]]> https://voidnull.es/newsletter/newsletter-11/ 65e0578aadd21a0cbc977a65 Sun, 03 Mar 2024 10:44:39 +0100 Undécima Newsletter que escribimos desde ./voidNull! Si estás corto de tiempo, no te preocupes. Hemos resumido los mejores artículos, noticias y recursos de la semana en un solo lugar para tu conveniencia. ¡Disfruta de todos los artículos!


💬 En esta semana, hemos publicado estos artículos relevantes:

  • Configurar una VPN Site-to-Site con IPsec - Parte I
  • Configurar una VPN Site-to-Site con IPsec - Parte II
  • Configura una VPN con WireGuard y WireGuard-UI en Debian 12
  • Diferencias entre pause, hibernate, shutdown, stop y reboot en Proxmox
  • Instalar Home Assistant OS utilizando Proxmox 8.x
  • ... y mucho más!

🥷 Unos cuantos artículos sobre VPN

Este mes hemos realizado algunos artículos sobre VPNs, os dejamos aquí la recopilación:

Configurar una VPN Site-to-Site con IPsec

Configurar una VPN Site-to-Site con IPsec - Parte I
En este tutorial veremos como configurar uno de los lados pero habrá una segunda parte para configurar los dos extremos utilizando métodos diferentes.
Configurar una VPN Site-to-Site con IPsec - Parte II
En artículos anteriores configuramos la Zona Sur de esta configuración que estamos realizando.

Configura una VPN con WireGuard y WireGuard-UI en Debian 12

Configura una VPN con WireGuard y WireGuard-UI en Debian 12
Para este tutorial también utilizaremos WireGuard-UI que es una interfaz de usuario (UI) gráfica para WireGuard, diseñada para facilitar la gestión y configuración de esta VPN.

🐬 ¡Nuevos artículos en la etiqueta Gadgets!

Os presentamos los nuevos artículos sobre Flipper Zero en los que vais a flipar mucho! Os dejamos los nuevos artículos y ya os avisamos de que están por venir muchos más!

Explorando las capacidades de Flipper Zero: Herramientas esenciales

Las redes inalámbricas y los dispositivos IoT son cada vez más comunes en nuestras vidas, y con ello aumenta el riesgo de ciberataques. Para proteger estas redes y dispositivos, es esencial tener herramientas efectivas de prueba de seguridad. Una herramienta que ha ganado popularidad recientemente es el Flipper Zero. Este dispositivo ofrece una gama de capacidades para pruebas de seguridad inalámbrica y evaluaciones de vulnerabilidad, siendo esenciales para profesionales de la ciberseguridad.

Explorando las capacidades de Flipper Zero: Herramientas esenciales
Este artículo exploramos las características y capacidades de Flipper Zero y cómo se pueden utilizar para pruebas de seguridad inalámbrica.

Shht, sólo será un momento

🌟 ¡Hey! Espera un momentito... 🤚 Antes de que sigas devorando nuestros artículos (que sabemos que son irresistibles 😋), tengo algo importante que decirte. Esto no tiene mucho que ver con lo que estás leyendo, ¡pero es igual de emocionante! 🎉 Si te estás preguntando, "¿Cómo puedo ayudar a que este blog siga creando contenidos tan geniales?", tengo una idea brillante para ti. 💡

¿Qué tal una pequeña donación? 💖 Sí, como lo oyes. Con solo unos clics, puedes convertirte en nuestro héroe o heroína del día. 🦸🦸 No importa si es mucho o poco, cada granito de arena cuenta para que sigamos compartiendo artículos tan interesantes (o incluso más) como este. 💪

Así que, si te sientes generoso y quieres apoyarnos, ¡Adelante! Tu contribución nos ayudará a seguir adelante con nuestra misión de entretenerte e informarte. Y si no puedes, no te preocupes, ¡Seguiremos siendo amigos! 😊

¡Gracias por estar aquí y por ser parte de nuestra increíble comunidad! 🌈

Recuerda también que puedes invitar a tus amigos y familiares a formar parte de la comunidad y explicar los beneficios de registrarse en ./voidNull.


📖 Diccionario de comandos para GNU/Linux

Dentro del mundo de la administración de sistemas operativos basados en GNU/Linux, existen muchos comandos. Hay un subconjunto de comandos de shell como cd o mkdir y luego están los comandos de GNU coreutils como less. Además de todo esto, existen utilizades CLI adicionales como curl, wget, dt, entre muchas otras herramientas.

En ./voidNull tenemos previsto hacer un listado grande de los comandos más comunes y de otros comandos útiles para el día día del administrador de sistemas.

ipinfo: muestra toda la información de una IP

Hoy vengo con un comando muy interesante si eres sysadmin y tienes que saber de donde son ciertas IP. ipinfo es una versión oficial CLI de la web ipinfo.io que ofrece una base de datos muy grande con una API conectada para consultar todo tipo de información sobre una IP.

ipinfo: muestra toda la información de una IP
ipinfo es una versión oficial CLI de la web ipinfo.io que ofrece una base de datos muy grande con una API conectada para consultar todo tipo de información sobre una IP.

vmstat: obtén información detallada sobre el uso de memoria

El comando vmstat (Virtual Memory Statistics) es una herramienta de monitoreo de sistemas indispensable para cualquier administrador de sistemas que desee obtener información detallada sobre el uso de memoria, procesamiento, entrada/salida de disco, y actividad de intercambio en sistemas Unix/Linux.

vmstat: obtén información detallada sobre el uso de memoria
El comando vmstat (Virtual Memory Statistics) es una herramienta de monitoreo de sistemas indispensable para cualquier administrador de sistemas

¿Buscas otro comando?

¡Revisa nuestro "Diccionario de comandos para GNU/Linux"!

Diccionario de comandos para GNU/Linux

🤖 Curso de Ansible en ./voidNull

Iniciamos también un apartado con cursos específicos sobre temas relacionados con el despliegue entre otras cosas.

Módulos: Utilidades [Ansible #17]

Módulos: Utilidades [Ansible #17]
Ansible es una poderosa herramienta de automatización que utiliza una arquitectura simple pero efectiva para gestionar configuraciones y orquestar tareas. Una parte clave de esta arquitectura son los módulos, que son unidades de código que Ansible ejecuta.

Módulos: Notificaciones [Ansible #18]

Módulos: Notificaciones [Ansible #18]
Una característica clave de Ansible es su capacidad para integrarse con sistemas de notificación, lo que facilita la comunicación entre equipos y sistemas.

ARTÍCULO DE LA SEMANA

El artículo seleccionado para esta semana es...

🦊 Despligue del tema de Ghost utilizando GitLab CI

En el siguiente tutorial vamos a explicar como trabajar con la integración continua de GitLab y con el desarrollo de nuestro tema de Ghost.

Despliegue del tema de Ghost utilizando GitLab CI
En el siguiente tutorial vamos a explicar como trabajar con la integración continua de GitLab y con el desarrollo de nuestro tema de Ghost.

Otros artículos interesantes de este mes:

]]>
<![CDATA[ Copiar .ISO en nuestro Proxmox ]]> https://voidnull.es/copiar-iso-en-nuestro-proxmox/ 65de0cdcadd21a0cbc9776a1 Fri, 01 Mar 2024 10:24:14 +0100 Una de las característica de Proxmox es que nos permite tener en nuestro almacenamiento imágenes ISO para luego utilizarlas para desplegar servidores virtuales.

En el siguiente tutorial os vamos a explicar todas las formas posibles para copiar imágenes ISO dentro de Proxmox. Para todos los ejemplos, usaremos la ISO de Ubuntu Server, pero se puede usar cualquier otra ISO.

💡
Este tutorial pertenece a un curso de Proxmox, si te interesa el tema, puedes ver todos los tutoriales en la siguiente URL: Cursos de ./voidNull

Cargar imagen ISO desde tu ordenador

Este primer procedimiento, puede ser igual el más sencillo, lo que haremos será ir a la web oficial de Ubuntu y nos descargaremos la versión de Ubuntu Server.

Ya dentro de Proxmox, en la barra lateral, desplegaremos nuestro Datacenter y deberemos de seleccionar nuestro almacenamiento donde guardaremos nuestras ISO. Luego tendremos que hacer clic sobre la opción ISO Images.

En este apartado, tendremos que hacer clic sobre el botón Upload y se nos abrirá la siguiente ventana:

Aquí deberemos de seleccionar el fichero haciendo clic en Select File y seleccionaremos el fichero en nuestro ordenador. Una vez hayamos seleccionado el fichero, podremos cambiar el nombre del fichero si queremos.

En este punto, podremos hacer clic en Upload para iniciar la carga de la imagen en nuestro Proxmox, el proceso puede tardar un poco:

Una vez finalice la carga, ya tendremos la imagen disponible para poderla utilizar en el despliegue de nuestras máquinas.

Cargar imagen directamente desde una URL

Otra opción que tenemos, y esta es mi favorita, es hacer la descarga de la ISO directamente en Proxmox. Para esta opción hay que hacer clic sobre el botón Download from URL y copiar la URL del fichero ISO.

Al copiar la URL, podemos hacer clic sobre el botón Query URL para que rellene la configuración de forma automática. Una vez tenemos todo listo, podemos hacer clic sobre el botón de Download para iniciar la descarga:

Este procedimiento hace la descarga directamente en nuestro servidor, por lo que no es necesario hacer la descarga en nuestro ordenador con antelación.

Una vez finalice la carga, ya tendremos la imagen disponible para poderla utilizar en el despliegue de nuestras máquinas.

Cargar ISO directamente por línea de comandos

Teniendo las otras opciones, este modo de copiar la ISO puede ser un poco engorroso, pero en alguna ocasión podemos encontrar necesario hacer esto, así que aquí va esta explicación.

Deberemos de conectarnos al servidor Proxmox ya sea por SSH o bien usando la Shell incorporada en la interfaz de Proxmox.

Accederemos a la siguiente ruta:

cd /var/lib/vz/template/iso

Y aquí descargaremos la ISO utilizando el comando wget:

wget https://releases.ubuntu.com/22.04.4/ubuntu-22.04.4-live-server-amd64.iso

Salida del comando

--2024-02-27 19:05:49-- https://releases.ubuntu.com/22.04.4/ubuntu-22.04.4-live-server-amd64.iso
Resolving releases.ubuntu.com (releases.ubuntu.com)... 91.189.91.124, 185.125.190.40, 91.189.91.123, ...
Connecting to releases.ubuntu.com (releases.ubuntu.com)|91.189.91.124|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 2104408064 (2.0G) [application/x-iso9660-image]
Saving to: ‘ubuntu-22.04.4-live-server-amd64.iso’

ubuntu-22.04.4-live-server-amd64.iso 100%[========================================================>] 1.96G 9.88MB/s in 3m 12s

2024-02-27 19:09:01 (10.5 MB/s) - ‘ubuntu-22.04.4-live-server-amd64.iso’ saved [2104408064/2104408064]

Ahora si vamos a nuestro almacenamiento y vamos al apartado de ISO Images podremos observar que se encuentra nuestra ISO disponible:

]]>