Jekyll2023-11-06T18:57:42+01:00https://lordpedal.github.io/feed.xmlOverclock Server... la culminación de un fin es el comienzo de una realidad.LordpedalDebian 12 Bookworm: Servidor PC2023-07-15T12:00:00+02:002023-07-15T13:00:00+02:00https://lordpedal.github.io/gnu/linux/debian-12-servidor<p class="full"><img src="https://lordpedal.github.io/assets/images/Debian.png" alt="Debian" class="align-center" /></p>
<p>En esta sección pretendo hablar de como optimizar y adaptar la distribución <strong>Debian Bookworm</strong> a un uso diario como <strong>Servidor doméstico</strong>, desde mi propia experiencia de usuario.</p>
<p>El recomendar <code class="language-plaintext highlighter-rouge">Debian</code> es poder usar la combinación de un <strong>Sistema Operativo Libre y alternativo</strong> con una gran comunidad de soporte detrás del proyecto.</p>
<p>En la <a href="https://www.debian.org/releases/stable/" class="btn btn--warning btn--small" target="_blank">web de descargas</a> podremos elegir la distribución que más se adapte a nuestras necesidades.</p>
<p>Para el caso de esta guía vamos a emplear la plataforma <code class="language-plaintext highlighter-rouge">AMD64</code>, que es la <em>más recomendable</em> para uso en un PC con <strong>Procesador 64bits</strong> <a href="https://cdimage.debian.org/debian-cd/current/amd64/iso-cd/" class="btn btn--success btn--small" target="_blank">Descarga directa</a></p>
<p>Adicionalmente en la propia web podemos encontrar unas excelentes <a href="https://www.debian.org/releases/stable/installmanual" class="btn btn--warning btn--small" target="_blank">guías de instalación</a> donde el proceso de instalación es guiado con todo tipo de detalles.</p>
<p>Resumiendo el procedimiento a grandes rasgos:</p>
<ol>
<li>Grabamos la ISO descargada en un CD/DVD o USB según capacidad y necesidad.</li>
<li>Seleccionamos la opción de arranque desde el nuevo dispositivo en la configuración de nuestra UEFI/BIOS. Obligatorio deseleccionar opción de arranque rápido en Windows en caso de tenerlo activo y/o instalado.</li>
<li>Ejecutamos el asistente de instalación.</li>
<li><strong>Importante</strong> tildar para instalar en sistema durante asistente instalación: <code class="language-plaintext highlighter-rouge">Entorno de escritorio Debian + MATE + SSH server + Utilidades estándar del sistema Debian</code>, el resto de opciones recomiendo descartarlas.</li>
<li>Disfrutar de las bondades de un gran sistema operativo y una gran comunidad asociada al mismo.</li>
</ol>
<figure>
<a href="/assets/images/posts/install12.jpg"><img src="/assets/images/posts/install12.jpg" /></a>
</figure>
<h2 id="sistema-base">Sistema Base</h2>
<p>El usuario de sistema sobre el que realizare la guía es <code class="language-plaintext highlighter-rouge">pi</code> para seguir en la linea del blog, recordad sustituir dicho usuario por el que habéis creado durante la instalación.</p>
<p>Planteado el guión inicial vamos a personalizar nuestra instalación, pero antes recordando que los ajustes en su mayor parte los ejecutaremos desde una <em>terminal de sistema</em>.</p>
<h3 id="configurando-sudo">Configurando: <a href="https://es.wikipedia.org/wiki/Sudo" target="_blank">SUDO</a></h3>
<p>Lo primero con lo que comenzamos es añadiendo nuestro usuario al grupo <code class="language-plaintext highlighter-rouge">sudo</code> del sistema, para ello ejecutamos en la terminal:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>su
</code></pre></div></div>
<p>Se nos solicitara la <em>contraseña</em> de <strong>root</strong> que previamente le dimos en la instalación. Procedemos a instalar la aplicación:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>apt-get update <span class="o">&&</span> apt-get <span class="nt">-y</span> <span class="nb">install sudo </span>nano
</code></pre></div></div>
<p>A continuacion debemos de añadir nuestro usuario a los principales grupos del sistema, entre ellos <strong>sudo</strong>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> /sbin <span class="o">&&</span> <span class="se">\</span>
./usermod <span class="nt">-aG</span> audio pi <span class="o">&&</span> <span class="se">\</span>
./usermod <span class="nt">-aG</span> video pi <span class="o">&&</span> <span class="se">\</span>
./usermod <span class="nt">-aG</span> dialout pi <span class="o">&&</span> <span class="se">\</span>
./usermod <span class="nt">-aG</span> plugdev pi <span class="o">&&</span> <span class="se">\</span>
./usermod <span class="nt">-aG</span> <span class="nb">tty </span>pi <span class="o">&&</span> <span class="se">\</span>
./usermod <span class="nt">-aG</span> <span class="nb">sudo </span>pi
</code></pre></div></div>
<p>Si no es así haz caso omiso, el fallo reside en el <strong>PATH del Sistema</strong> que durante el resto de configuraciones del server se corrige.</p>
<p>Vamos a repasar los principales atajos de teclado que encontramos en el editor <a href="https://es.wikipedia.org/wiki/GNU_Nano" class="btn btn--inverse btn--small" target="_blank">nano</a>:</p>
<table class="notice--info">
<thead>
<tr>
<th>Acción</th>
<th>Resultado</th>
</tr>
</thead>
<tbody>
<tr>
<td>Control + O</td>
<td>Guardar fichero</td>
</tr>
<tr>
<td>Control + X</td>
<td>Salir del editor</td>
</tr>
<tr>
<td>Control + X</td>
<td>Salir del editor</td>
</tr>
<tr>
<td>Control + C</td>
<td>Muestra número linea donde se encuentra cursor</td>
</tr>
<tr>
<td>Control + K</td>
<td>Cortar linea</td>
</tr>
<tr>
<td>Control + U</td>
<td>Pegar linea</td>
</tr>
<tr>
<td>Control + W</td>
<td>Buscar en el fichero</td>
</tr>
<tr>
<td>Control + W + R</td>
<td>Buscar y reemplazar en el fichero</td>
</tr>
</tbody>
</table>
<p>Añadimos privilegios <em>sudo</em> a nuestro usuario editando la configuración:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>nano /etc/sudoers
</code></pre></div></div>
<p>Y agregamos la siguiente sentencia al final del archivo:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi <span class="nv">ALL</span><span class="o">=(</span>ALL<span class="o">)</span> NOPASSWD: ALL
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y salimos de la sesión root.</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">exit</span>
</code></pre></div></div>
<p>Y ya tendremos configurado debidamente el perfil sudo en nuestro usuario de sistema.</p>
<h3 id="ajustando-repositorios-sistema">Ajustando: Repositorios Sistema</h3>
<p>El <a href="https://es.wikipedia.org/wiki/Sistema_de_gesti%C3%B3n_de_paquetes" class="btn btn--inverse btn--small" target="_blank">gestor de paquetes</a> <code class="language-plaintext highlighter-rouge">Apt</code>/<code class="language-plaintext highlighter-rouge">Aptitude</code>/<code class="language-plaintext highlighter-rouge">Synaptic</code> de nuestra distribución se basa en un listado de fuentes de instalación.
Primero haremos un backup de las actuales y crearemos una personalizada:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> /etc/apt <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo mv </span>sources.list sources.pi <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>nano sources.list
</code></pre></div></div>
<p>En el documento en blanco que se nos abre, añadimos las nuevas personalizadas:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># Oficiales</span>
deb http://deb.debian.org/debian/ bookworm main contrib non-free non-free-firmware
deb-src http://deb.debian.org/debian/ bookworm main contrib non-free non-free-firmware
<span class="c"># Seguridad</span>
deb http://security.debian.org/debian-security bookworm-security main contrib non-free non-free-firmware
deb-src http://security.debian.org/debian-security bookworm-security main contrib non-free non-free-firmware
<span class="c"># Actualizaciones Sistema</span>
deb http://deb.debian.org/debian/ bookworm-updates main contrib non-free non-free-firmware
deb-src http://deb.debian.org/debian/ bookworm-updates main contrib non-free non-free-firmware
<span class="c"># Actualizaciones Sistema Backports</span>
deb http://deb.debian.org/debian bookworm-backports main contrib non-free non-free-firmware
deb-src http://deb.debian.org/debian bookworm-backports main contrib non-free non-free-firmware
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y actualizamos el listado de paquetes de software y posibles actualizaciones del mismo:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt-get clean <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get autoclean <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> autoremove <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get update <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> upgrade <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> dist-upgrade
</code></pre></div></div>
<p>Tras finalizar la actualización tendremos el sistema actualizado y con las últimas novedades/parches instalados.</p>
<h3 id="utilidades-sistema">Utilidades Sistema</h3>
<p>Posiblemente tendrás algún <code class="language-plaintext highlighter-rouge">controlador</code> pendiente de actualizar y/o instalar el <code class="language-plaintext highlighter-rouge">driver necesario</code> para poder interactuar con el y no esta compilado en el kernel. Una solución sencilla es instalar un paquete con algunos de los principales drivers (3Com, Atheros, Radeon, …), y si además queremos maximizar la eficiencia de nuestro procesador instalaremos este parche:</p>
<blockquote class="notice--info">
<p>AMD 64bits & INTEL 64bits</p>
</blockquote>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt-get update <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> <span class="nb">install </span>firmware-linux-nonfree <span class="se">\</span>
amd64-microcode intel-microcode
</code></pre></div></div>
<p>Si necesitamos <code class="language-plaintext highlighter-rouge">des/comprimir</code> algún fichero de nuestro sistema y no se encuentra dentro de los formatos más habituales de GNU/Linux, deberemos de darle soporte para poder interactuar:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt-get update <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> <span class="nb">install </span>rar unrar zip unzip unace bzip2 lzop p7zip <span class="se">\</span>
p7zip-full p7zip-rar sharutils lzip xz-utils mpack arj cabextract
</code></pre></div></div>
<p>Otro conjunto de <code class="language-plaintext highlighter-rouge">utilidades adicionales</code> a instalar que necesitaremos para futuros usos son:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt-get update <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> <span class="nb">install </span>mc htop curl bc git wget curl dnsutils exfat-fuse ntfs-3g hfsprogs <span class="se">\</span>
hfsplus build-essential automake libtool uuid-dev psmisc linux-source yasm lsof <span class="se">\</span>
autoconf g++ subversion linux-source tofrodos git-core subversion dos2unix <span class="se">\</span>
make gcc automake cmake git-core dpkg-dev fakeroot pbuilder dh-make debhelper devscripts <span class="se">\</span>
patchutils quilt git-buildpackage pristine-tar git yasm cvs mercurial libexif<span class="k">*</span> libid3tag<span class="k">*</span> <span class="se">\</span>
libavutil<span class="k">*</span> libavcodec-dev libavformat-dev libjpeg-dev libsqlite3-dev libexif-dev libid3tag0-dev <span class="se">\</span>
libogg-dev libvorbis-dev libflac-dev ffmpeg libssl-dev libgnutls-openssl-dev <span class="se">\</span>
linux-headers-<span class="sb">`</span><span class="nb">uname</span> <span class="nt">-r</span><span class="sb">`</span>
</code></pre></div></div>
<h3 id="configurando-idioma-sistema">Configurando Idioma Sistema</h3>
<p>Ejecutaremos un pequeño asistente con la orden de terminal:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>dpkg-reconfigure locales
</code></pre></div></div>
<p>Para poner nuestro sistema en español, tenemos que marcar las siguientes opciones en el asistente configuración de locales y deseleccionar cualquier otra que pudiese estar activa:</p>
<ul class="task-list notice">
<li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled="disabled" />en_GB.UTF-8 UTF-8</li>
<li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled="disabled" checked="checked" />es_ES.UTF-8 UTF-8</li>
</ul>
<p>Para la configuración regional predeterminada seleccionamos:</p>
<ul class="task-list notice">
<li class="task-list-item"><input type="checkbox" class="task-list-item-checkbox" disabled="disabled" checked="checked" />es-ES.UTF-8</li>
</ul>
<p>Ejemplo salida comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@overclock:~ <span class="nv">$ </span><span class="nb">sudo </span>dpkg-reconfigure locales
Generating locales <span class="o">(</span>this might take a <span class="k">while</span><span class="o">)</span>...
es_ES.UTF-8... <span class="k">done
</span>Generation complete.
</code></pre></div></div>
<p>Y a continuación configuro franja horaria sistema con el asistente:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>dpkg-reconfigure tzdata
</code></pre></div></div>
<p>Ejemplo salida comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@roverclock:~ <span class="nv">$ </span><span class="nb">sudo </span>dpkg-reconfigure tzdata
Current default <span class="nb">time </span>zone: <span class="s1">'Europe/Madrid'</span>
Local <span class="nb">time </span>is now: Sat Jul 15 18:00:20 CEST 2023.
Universal Time is now: Sat Jul 15 16:00:20 UTC 2023.
</code></pre></div></div>
<h3 id="configurando-tty">Configurando <a href="https://es.wikipedia.org/wiki/Emulador_de_terminal" target="_blank">TTY</a></h3>
<p>Este paso aunque no es obligatorio en un entorno de Servidor, si lo considero que es altamente recomendado para optimizar recursos de sistema. Lo que vamos a hacer es deshabilitar el autoinicio del entorno gráfico instalado <a href="https://es.wikipedia.org/wiki/MATE" class="btn btn--info btn--small" target="_blank">MATE</a></p>
<p>Lo que debemos de hacer a continuacón es adaptar el sistema a un arranque sin gestor de inicio sesiones <a href="https://es.wikipedia.org/wiki/LightDM" class="btn btn--danger btn--small" target="_blank">LightDM</a></p>
<p>Para ello instalamos y configuramos la siguiente dependencia:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt-get <span class="nt">-y</span> <span class="nb">install </span>xserver-xorg-legacy
</code></pre></div></div>
<p>Vamos a reconfigurarla debidamente, previo backup de su configuración:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo mv</span> /etc/X11/Xwrapper.config /etc/X11/Xwrapper.bak <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>nano /etc/X11/Xwrapper.config
</code></pre></div></div>
<p>Agregamos el siguiente contenido al fichero que estamos editando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># Xwrapper.config (Debian X Window System server wrapper configuration file)</span>
<span class="c">#</span>
<span class="c"># This file was generated by the post-installation script of the</span>
<span class="c"># xserver-xorg-legacy package using values from the debconf database.</span>
<span class="c">#</span>
<span class="c"># See the Xwrapper.config(5) manual page for more information.</span>
<span class="c">#</span>
<span class="c"># This file is automatically updated on upgrades of the xserver-xorg-legacy</span>
<span class="c"># package *only* if it has not been modified since the last upgrade of that</span>
<span class="c"># package.</span>
<span class="c">#</span>
<span class="c"># If you have edited this file but would like it to be automatically updated</span>
<span class="c"># again, run the following command as root:</span>
<span class="c"># dpkg-reconfigure xserver-xorg-legacy</span>
<span class="nv">needs_root_rights</span><span class="o">=</span><span class="nb">yes
</span><span class="nv">allowed_users</span><span class="o">=</span>anybody
</code></pre></div></div>
<p>Guardamos los cambios y salimos del editor de texto. Ahora vamos a reconfigurar SystemD para el arranque en terminal:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>systemctl set-default multi-user.target
</code></pre></div></div>
<p>Llegado a este punto el sistema tras un reinicio o encendido del PC nos solicitaria el usuario: <strong>pi</strong> y su contraseña: <strong>**</strong><strong>**</strong> para hacer login en terminal.</p>
<p>Podemos configurar un <strong>autologin</strong> que <strong>no lo recomiendo</strong> pero lo dejo a modo informativo.</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo mkdir</span> <span class="nt">-p</span> /etc/systemd/system/getty@tty1.service.d <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>nano /etc/systemd/system/getty@tty1.service.d/override.conf
</code></pre></div></div>
<p>Agregamos el siguiente contenido al fichero que estamos editando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">[</span>Service]
<span class="nv">Type</span><span class="o">=</span>simple
<span class="nv">ExecStart</span><span class="o">=</span>
<span class="nv">ExecStart</span><span class="o">=</span>-/sbin/agetty <span class="nt">--autologin</span> pi <span class="nt">--noclear</span> %I 38400 linux
</code></pre></div></div>
<p>Guardamos los cambios y salimos del editor de texto.</p>
<h3 id="configurando-rclocal">Configurando RC.LOCAL</h3>
<p>Si no queremos crear un script único para la ejecución de un comando o un script cada vez que iniciamos un sistema tipo Unix (BSD, Gnu/Linux, etc) tenemos la posibilidad de llamarlo desde el fichero <strong>/etc/rc.local</strong>.</p>
<p>Cualquier comando que coloquemos o script al que llamemos en dicho fichero será ejecutado al final del arranque, es decir, cuando todos los scripts que tenemos en el runlevel correspondiente hayan sido ejecutados.</p>
<p>Esta opción no viene habilitada por defecto en Debian 11 y para ello tendremos que habilitarla, creamos el servicio para <a href="https://es.wikipedia.org/wiki/Systemd" class="btn btn--inverse btn--small" target="_blank">Systemd</a>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/systemd/system/rc-local.service
</code></pre></div></div>
<p>Agregamos el siguiente contenido al fichero que estamos editando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">[</span>Unit]
<span class="nv">Description</span><span class="o">=</span>Script /etc/rc.local
<span class="nv">ConditionPathExists</span><span class="o">=</span>/etc/rc.local
<span class="o">[</span>Service]
<span class="nv">Type</span><span class="o">=</span>forking
<span class="nv">ExecStart</span><span class="o">=</span>/etc/rc.local start
<span class="nv">TimeoutSec</span><span class="o">=</span>0
<span class="nv">StandardOutput</span><span class="o">=</span><span class="nb">tty
</span><span class="nv">RemainAfterExit</span><span class="o">=</span><span class="nb">yes
</span><span class="nv">SysVStartPriority</span><span class="o">=</span>99
<span class="o">[</span>Install]
<span class="nv">WantedBy</span><span class="o">=</span>multi-user.target
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto, ahora pasamos a crear el fichero <strong>rc.local</strong></p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/rc.local
</code></pre></div></div>
<p>Agregamos el siguiente contenido al fichero que estamos editando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#!/bin/sh -e</span>
<span class="c">#</span>
<span class="c"># rc.local</span>
<span class="c">#</span>
<span class="c"># This script is executed at the end of each multiuser runlevel.</span>
<span class="c"># Make sure that the script will "exit 0" on success or any other</span>
<span class="c"># value on error.</span>
<span class="c">#</span>
<span class="c"># In order to enable or disable this script just change the execution</span>
<span class="c"># bits.</span>
<span class="c">#</span>
<span class="c"># By default this script does nothing.</span>
<span class="c"># SALIR</span>
<span class="nb">exit </span>0
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto, debemos de darle permisos de ejecución al ficher creado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo chmod</span> +x /etc/rc.local
</code></pre></div></div>
<p>Habilitamos el servicio para que se ejecute al inicio del sistema y lo lanzamos para comprobar el correcto funcionamiento:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>systemctl <span class="nb">enable </span>rc-local <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>systemctl start rc-local.service <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>systemctl status rc-local.service
</code></pre></div></div>
<p>Llegado a este punto de configuración del servidor recomiendo un reset al sistema:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>reboot
</code></pre></div></div>
<p>Tras el reinicio el sistema arrancara en <code class="language-plaintext highlighter-rouge">TTY</code>. Adjunto cuadro resumen con los principales comandos terminal:</p>
<table class="notice--info">
<thead>
<tr>
<th>Comando terminal</th>
<th>Resultado</th>
</tr>
</thead>
<tbody>
<tr>
<td>startx</td>
<td>Arrancar entorno gráfico (MATE)</td>
</tr>
<tr>
<td>exit</td>
<td>Salir/Cerrar sesión TTY</td>
</tr>
<tr>
<td>sudo su</td>
<td>Iniciar sesion como ROOT</td>
</tr>
<tr>
<td>sudo reboot</td>
<td>Reiniciar sistema</td>
</tr>
<tr>
<td>sudo poweroff</td>
<td>Apagar sistema</td>
</tr>
</tbody>
</table>
<h3 id="alías">Alías</h3>
<p>En informática <code class="language-plaintext highlighter-rouge">alias</code> es una <strong>orden disponible</strong> en varios <strong>intérpretes de comandos</strong> tales como los <strong>shells de Unix, 4DOS/4NT y Windows PowerShell</strong>, que permite reemplazar una palabra o serie de palabras con otra. Su uso principal es el de abreviar órdenes o para añadir argumentos de forma predeterminada a una orden que se usa con mucha frecuencia. Los alias se mantienen hasta que se termina la sesión en la terminal, pero normalmente se suelen añadir en el fichero de configuración del intérprete de órdenes para de esta forma siempre están disponibles para todas las sesiones de terminal.</p>
<p>Un ejemplo clarifica este tema de forma sencilla, en <strong>TTY</strong> un alías que suelo usar es <code class="language-plaintext highlighter-rouge">reiniciar</code>, que ejecuta la orden <code class="language-plaintext highlighter-rouge">sudo reboot</code>.</p>
<p>Para configurar los alías editaremos el fichero de configuración de nuestra distro para que tanto el usuario <code class="language-plaintext highlighter-rouge">root</code> como <code class="language-plaintext highlighter-rouge">pi</code> tengan acceso a ellos:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/bash.bashrc
</code></pre></div></div>
<p>Y añadiremos al final del fichero los alías que definamos, adjunto mi fichero de configuración:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># System-wide .bashrc file for interactive bash(1) shells.</span>
<span class="c"># To enable the settings / commands in this file for login shells as well,</span>
<span class="c"># this file has to be sourced in /etc/profile.</span>
<span class="c"># If not running interactively, don't do anything</span>
<span class="o">[</span> <span class="nt">-z</span> <span class="s2">"</span><span class="nv">$PS1</span><span class="s2">"</span> <span class="o">]</span> <span class="o">&&</span> <span class="k">return</span>
<span class="c"># check the window size after each command and, if necessary,</span>
<span class="c"># update the values of LINES and COLUMNS.</span>
<span class="nb">shopt</span> <span class="nt">-s</span> checkwinsize
<span class="c"># set variable identifying the chroot you work in (used in the prompt below)</span>
<span class="k">if</span> <span class="o">[</span> <span class="nt">-z</span> <span class="s2">"</span><span class="k">${</span><span class="nv">debian_chroot</span><span class="k">:-}</span><span class="s2">"</span> <span class="o">]</span> <span class="o">&&</span> <span class="o">[</span> <span class="nt">-r</span> /etc/debian_chroot <span class="o">]</span><span class="p">;</span> <span class="k">then
</span><span class="nv">debian_chroot</span><span class="o">=</span><span class="si">$(</span><span class="nb">cat</span> /etc/debian_chroot<span class="si">)</span>
<span class="k">fi</span>
<span class="c"># set a fancy prompt (non-color, overwrite the one in /etc/profile)</span>
<span class="nv">PS1</span><span class="o">=</span><span class="s1">'${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '</span>
<span class="c"># Commented out, don't overwrite xterm -T "title" -n "icontitle" by default.</span>
<span class="c"># If this is an xterm set the title to user@host:dir</span>
<span class="c">#case "$TERM" in</span>
<span class="c">#xterm*|rxvt*)</span>
<span class="c"># PROMPT_COMMAND='echo -ne "\033]0;${USER}@${HOSTNAME}: ${PWD}\007"'</span>
<span class="c"># ;;</span>
<span class="c">#*)</span>
<span class="c"># ;;</span>
<span class="c">#esac</span>
<span class="c"># enable bash completion in interactive shells</span>
<span class="c">#if ! shopt -oq posix; then</span>
<span class="c"># if [ -f /usr/share/bash-completion/bash_completion ]; then</span>
<span class="c"># . /usr/share/bash-completion/bash_completion</span>
<span class="c"># elif [ -f /etc/bash_completion ]; then</span>
<span class="c"># . /etc/bash_completion</span>
<span class="c"># fi</span>
<span class="c">#fi</span>
<span class="c"># if the command-not-found package is installed, use it</span>
<span class="k">if</span> <span class="o">[</span> <span class="nt">-x</span> /usr/lib/command-not-found <span class="nt">-o</span> <span class="nt">-x</span> /usr/share/command-not-found/command-not-found <span class="o">]</span><span class="p">;</span> <span class="k">then
function </span>command_not_found_handle <span class="o">{</span>
<span class="c"># check because c-n-f could've been removed in the meantime</span>
<span class="k">if</span> <span class="o">[</span> <span class="nt">-x</span> /usr/lib/command-not-found <span class="o">]</span><span class="p">;</span> <span class="k">then</span>
/usr/lib/command-not-found <span class="nt">--</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span>
<span class="k">return</span> <span class="nv">$?</span>
<span class="k">elif</span> <span class="o">[</span> <span class="nt">-x</span> /usr/share/command-not-found/command-not-found <span class="o">]</span><span class="p">;</span> <span class="k">then</span>
/usr/share/command-not-found/command-not-found <span class="nt">--</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span>
<span class="k">return</span> <span class="nv">$?</span>
<span class="k">else
</span><span class="nb">printf</span> <span class="s2">"%s: command not found</span><span class="se">\n</span><span class="s2">"</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span> <span class="o">></span>&2
<span class="k">return </span>127
<span class="k">fi</span>
<span class="o">}</span>
<span class="k">fi</span>
<span class="c">#</span>
<span class="c"># Alias</span>
<span class="c">#</span>
<span class="nb">alias </span><span class="nv">reiniciar</span><span class="o">=</span><span class="s2">"sudo reboot"</span>
<span class="nb">alias </span><span class="nv">apagar</span><span class="o">=</span><span class="s2">"sudo poweroff"</span>
<span class="nb">alias </span><span class="nv">instalar</span><span class="o">=</span><span class="s2">"sudo apt-get -y install"</span>
<span class="nb">alias </span><span class="nv">desinstalar</span><span class="o">=</span><span class="s2">"sudo apt-get -y purge"</span>
<span class="nb">alias </span><span class="nv">actualizar</span><span class="o">=</span><span class="s2">"sudo apt-get autoclean && sudo apt-get clean && sudo apt-get -y autoremove && sudo apt-get update && sudo apt-get -y upgrade && sudo apt-get -y dist-upgrade && sudo apt-get moo"</span>
<span class="nb">alias </span><span class="nv">limpiarcache</span><span class="o">=</span><span class="s2">"sudo ldconfig && sudo sync && sudo sysctl -w vm.drop_caches=2 && sudo sync"</span>
<span class="nb">alias </span><span class="nv">win</span><span class="o">=</span><span class="s2">"startx"</span>
<span class="nb">alias </span><span class="nv">enlaces</span><span class="o">=</span><span class="s2">"sudo nano /etc/bash.bashrc"</span>
<span class="nb">alias </span><span class="nv">grubfix</span><span class="o">=</span><span class="s2">"sudo nano /etc/default/grub && sudo update-grub"</span>
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y para activarlos tendremos que volver a abrir la sesión TTY para ello solo basta con salir de ella:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">exit</span>
</code></pre></div></div>
<p>Y cuando tengamos de nuevo la <strong>TTY</strong> operativa con lanzar el comando <code class="language-plaintext highlighter-rouge">actualizar</code> se nos actualizara el <strong>Sistema Operativo</strong> a las última versión disponible.</p>
<p>Dejo un extracto de la ejecución del comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@overclock:~<span class="nv">$ </span>actualizar
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias... Hecho
Leyendo la información de estado... Hecho
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias... Hecho
Leyendo la información de estado... Hecho
0 actualizados, 0 nuevos se instalarán, 0 para eliminar y 0 no actualizados.
Obj:1 http://deb.debian.org/debian bookworm InRelease
Des:2 http://deb.debian.org/debian bookworm-updates InRelease <span class="o">[</span>36,8 kB]
Obj:3 http://security.debian.org/debian-security bookworm-security InRelease
Descargados 36,8 kB en 3s <span class="o">(</span>11,9 kB/s<span class="o">)</span>
Leyendo lista de paquetes... Hecho
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias... Hecho
Leyendo la información de estado... Hecho
Calculando la actualización... Hecho
0 actualizados, 0 nuevos se instalarán, 0 para eliminar y 0 no actualizados.
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias... Hecho
Leyendo la información de estado... Hecho
Calculando la actualización... Hecho
0 actualizados, 0 nuevos se instalarán, 0 para eliminar y 0 no actualizados.
<span class="o">(</span>__<span class="o">)</span>
<span class="o">(</span>oo<span class="o">)</span>
/------<span class="se">\/</span>
/ | <span class="o">||</span>
<span class="k">*</span> /<span class="se">\-</span><span class="nt">--</span>/<span class="se">\ </span>
~~ ~~
...<span class="s2">"Have you mooed today?"</span>...
</code></pre></div></div>
<h3 id="optimizar-ssd">Optimizar SSD</h3>
<p>Si contamos con <strong>más de 4GB de RAM</strong>, podemos hacer que la carpeta temporal del sistema no use el disco duro. Es la carpeta donde escriben muchas aplicaciones que estamos usando. Son datos que se borran al apagar el ordenador, con lo que no nos importa que se escriban en RAM. Para activarlo editamos nuevamente fstab:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/fstab
</code></pre></div></div>
<p>Y agregamos la siguiente sentencia al final del fichero:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># MODS SSD</span>
tmpfs /tmp tmpfs noatime,nodiratime,nodev,nosuid,mode<span class="o">=</span>1777,defaults 0 0
</code></pre></div></div>
<p>Guardamos los cambios y salimos del editor de texto. Adjunto como queda mi fichero <strong>fstab</strong>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># /etc/fstab: static file system information.</span>
<span class="c">#</span>
<span class="c"># Use 'blkid' to print the universally unique identifier for a</span>
<span class="c"># device; this may be used with UUID= as a more robust way to name devices</span>
<span class="c"># that works even if disks are added and removed. See fstab(5).</span>
<span class="c">#</span>
<span class="c"># <file system> <mount point> <type> <options> <dump> <pass></span>
<span class="c"># / was on /dev/sdc2 during installation</span>
<span class="c">#</span>
<span class="c"># SSD</span>
<span class="nv">UUID</span><span class="o">=</span>ea691ed1-9a94-47b3-8534-3e00c7f0922f / ext4 noatime,nodelalloc,i_version,inode_readahead_blks<span class="o">=</span>64,errors<span class="o">=</span>remount-ro 0 1
<span class="c"># SWAP </span>
<span class="nv">UUID</span><span class="o">=</span>b64de4e0-eedf-4e31-aeeb-e460ef6ac57c none swap sw 0 0
<span class="c">#</span>
<span class="c"># Lector DVD</span>
<span class="c">#/dev/sr0 /media/cdrom0 udf,iso9660 user,noauto 0 0</span>
<span class="c">#</span>
<span class="c"># NAS</span>
<span class="nv">UUID</span><span class="o">=</span>2f42917d-7c1f-4b7f-bff0-963f19b9dcf5 /media/rednas ext4 defaults,relatime 0 0
<span class="c">#</span>
<span class="c"># MODS SSD</span>
tmpfs /tmp tmpfs noatime,nodiratime,nodev,nosuid,mode<span class="o">=</span>1777,defaults 0 0
</code></pre></div></div>
<p>La partición swap, como ya sabéis es una partición cuyo fin principal es su uso cuando la RAM está llena, pero la cual no está vacía aunque tengas la RAM a la mitad.</p>
<p>Por ello es recomendable decirle al sistema que la use lo menos posible, sólo si es estrictamente necesario, editando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/sysctl.conf
</code></pre></div></div>
<p>Y agregamos al final del fichero las siguientes ordenes:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#</span>
<span class="c"># MODS</span>
<span class="c">#</span>
vm.overcommit_memory<span class="o">=</span>1
vm.swappiness<span class="o">=</span>1
vm.vfs_cache_pressure<span class="o">=</span>50
vm.dirty_writeback_centisecs<span class="o">=</span>1500
kernel.dmesg_restrict<span class="o">=</span>0
net.core.rmem_max<span class="o">=</span>16777216
net.core.wmem_max<span class="o">=</span>4194304
kernel.unprivileged_userns_clone<span class="o">=</span>1
fs.inotify.max_user_watches<span class="o">=</span>100000
</code></pre></div></div>
<p>Guardamos los cambios y salimos del editor de texto.</p>
<p>Has de saber que cuando borramos un fichero, el sistema operativo lo marca como espacio utilizable.</p>
<p>Los discos SSD pueden encargarse de controlar dichos bloques de espacio y reagruparlos, con lo que a través de la controladora del disco, la gestión del espacio será más rápida.</p>
<p>Para que la controladora se encargue, le solicitamos que analice el disco desde el sistema operativo con el comando <strong>fstrim</strong>.</p>
<p>Vamos a programar esta tarea, para que la realice a diario:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/cron.daily/fstrim
</code></pre></div></div>
<p>Y agregamos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#!/bin/sh</span>
/sbin/fstrim <span class="nt">--all</span> <span class="o">||</span> <span class="nb">true</span>
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y le damos permisos de ejecución:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo chmod</span> +x /etc/cron.daily/fstrim
</code></pre></div></div>
<p>Solamente nos queda reiniciar el Servidor para activar las nuevas mejoras:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>reboot
</code></pre></div></div>
<p>Adicionalmente me gusta agregar que tras 10 reinicios el sistema compruebe errores:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>tune2fs <span class="nt">-c</span> 10 /dev/sda1
</code></pre></div></div>
<h3 id="modding">Modding</h3>
<p>Antes de empezar con la parte de <strong>Modding</strong>, necesitamos instalar una dependencia, que nos dara información sobre la temperatura de nuestro sistema.</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt-get update <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> <span class="nb">install </span>lm-sensors
</code></pre></div></div>
<p>A continuación debemos de ejecutar un script instalado que nos detecta la configuración de nuestro <code class="language-plaintext highlighter-rouge">Servidor</code> y…</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>sensors-detect
</code></pre></div></div>
<p>…<strong>le damos continuamente a la tecla</strong> <code class="language-plaintext highlighter-rouge">INTRO</code> para que tome la respuesta por defecto que es siempre que sí y de esta forma buscará todos los chips que podría analizar.</p>
<p>Contiuamos hasta que nos salga la siguiente pregunta:</p>
<p><code class="language-plaintext highlighter-rouge">Do you want to add these lines to /etc/modules automatically? (yes/NO)</code></p>
<p>En este momento copiad y guardad en un documento de texto temporal lo que tenéis por encima entre los dos <strong>cut here</strong> (por ejemplo a mí me ha salido lo siguiente):</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#----cut here----</span>
<span class="c"># Chip drivers</span>
coretemp
<span class="c">#----cut here----</span>
</code></pre></div></div>
<p>Le damos nuevamente a <strong>INTRO</strong> para que no añada esas líneas automáticamente al fichero de <a href="https://es.wikipedia.org/wiki/M%C3%B3dulo_de_n%C3%BAcleo" class="btn btn--inverse btn--small" target="_blank">modulos</a> ya que las agregaremos manualmente para evitar posibles fallos de incompatibilidad, para ello editamos el fichero:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/modules
</code></pre></div></div>
<p>Y agregamos la siguientes lineas al final del fichero:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># Chip drivers</span>
coretemp
</code></pre></div></div>
<p>Guardamos los cambios y salimos del editor de texto. Muestro como ha quedado mi fichero:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@overclock:~<span class="nv">$ </span><span class="nb">cat</span> /etc/modules
<span class="c"># /etc/modules: kernel modules to load at boot time.</span>
<span class="c">#</span>
<span class="c"># This file contains the names of kernel modules that should be loaded</span>
<span class="c"># at boot time, one per line. Lines beginning with "#" are ignored.</span>
<span class="c">#</span>
<span class="c"># Chip drivers</span>
coretemp
</code></pre></div></div>
<p>Recomiendo reiniciar el Servidor para activar los cambios:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>reboot
</code></pre></div></div>
<p>Tras el reinicio ya podremos ver la información que hemos configurado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>sensors
</code></pre></div></div>
<p>En mi caso la información devuelta es la siguiente:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@overclock:~<span class="nv">$ </span>sensors
acpitz-virtual-0
Adapter: Virtual device
temp1: +27.8°C <span class="o">(</span>crit <span class="o">=</span> +119.0°C<span class="o">)</span>
temp2: +29.8°C <span class="o">(</span>crit <span class="o">=</span> +119.0°C<span class="o">)</span>
coretemp-isa-0000
Adapter: ISA adapter
Physical <span class="nb">id </span>0: +33.0°C <span class="o">(</span>high <span class="o">=</span> +84.0°C, crit <span class="o">=</span> +100.0°C<span class="o">)</span>
Core 0: +30.0°C <span class="o">(</span>high <span class="o">=</span> +84.0°C, crit <span class="o">=</span> +100.0°C<span class="o">)</span>
Core 1: +30.0°C <span class="o">(</span>high <span class="o">=</span> +84.0°C, crit <span class="o">=</span> +100.0°C<span class="o">)</span>
Core 2: +29.0°C <span class="o">(</span>high <span class="o">=</span> +84.0°C, crit <span class="o">=</span> +100.0°C<span class="o">)</span>
Core 3: +27.0°C <span class="o">(</span>high <span class="o">=</span> +84.0°C, crit <span class="o">=</span> +100.0°C<span class="o">)</span>
</code></pre></div></div>
<h4 id="userbashrc">$USER/.BASHRC</h4>
<p>El fichero <code class="language-plaintext highlighter-rouge">.bashrc</code> es un archivo script que se ejecuta cada vez que una nueva sesión de terminal server se inicia en el modo interactivo. Esto es lo que ocurre cuando se inicia TTY o simplemente abrir una nueva pestaña de terminal. Este fichero contiene una serie de configuraciones para la sesión de terminal. Vamos a editarlo para mejorarlo:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> /home/<span class="nv">$USER</span> <span class="o">&&</span> nano .bashrc
</code></pre></div></div>
<p>Buscamos la variable <code class="language-plaintext highlighter-rouge">#force_color_prompt=yes</code> y la descomentamos quedando en el fichero sin la <code class="language-plaintext highlighter-rouge">#</code> de la siguiente forma:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">force_color_prompt</span><span class="o">=</span><span class="nb">yes</span>
</code></pre></div></div>
<p>Nos movemos con el editor al final del fichero y añadimos el siguiente script:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># MOTD</span>
show_temp<span class="o">(){</span>
sensors | <span class="nb">grep</span> <span class="nt">-oP</span> <span class="s1">'Core 0.*?\+\K[0-9]+'</span>
<span class="o">}</span>
<span class="nb">let </span><span class="nv">upSeconds</span><span class="o">=</span><span class="s2">"</span><span class="si">$(</span>/usr/bin/cut <span class="nt">-d</span><span class="nb">.</span> <span class="nt">-f1</span> /proc/uptime<span class="si">)</span><span class="s2">"</span>
<span class="nb">let </span><span class="nv">secs</span><span class="o">=</span><span class="k">$((${</span><span class="nv">upSeconds</span><span class="k">}</span><span class="o">%</span><span class="m">60</span><span class="k">))</span>
<span class="nb">let </span><span class="nv">mins</span><span class="o">=</span><span class="k">$((${</span><span class="nv">upSeconds</span><span class="k">}</span><span class="o">/</span><span class="m">60</span><span class="o">%</span><span class="m">60</span><span class="k">))</span>
<span class="nb">let </span><span class="nv">horas</span><span class="o">=</span><span class="k">$((${</span><span class="nv">upSeconds</span><span class="k">}</span><span class="o">/</span><span class="m">3600</span><span class="o">%</span><span class="m">24</span><span class="k">))</span>
<span class="nb">let </span><span class="nv">dias</span><span class="o">=</span><span class="k">$((${</span><span class="nv">upSeconds</span><span class="k">}</span><span class="o">/</span><span class="m">86400</span><span class="k">))</span>
<span class="nv">UPTIME</span><span class="o">=</span><span class="sb">`</span><span class="nb">printf</span> <span class="s2">"%d dias, %02dh%02dm%02ds"</span> <span class="s2">"</span><span class="nv">$dias</span><span class="s2">"</span> <span class="s2">"</span><span class="nv">$horas</span><span class="s2">"</span> <span class="s2">"</span><span class="nv">$mins</span><span class="s2">"</span> <span class="s2">"</span><span class="nv">$secs</span><span class="s2">"</span><span class="sb">`</span>
<span class="nb">read </span>one five fifteen rest < /proc/loadavg
<span class="nb">echo</span> <span class="s2">"</span><span class="si">$(</span>tput setaf 2<span class="si">)</span><span class="s2">
</span><span class="sb">`</span><span class="nb">date</span> +<span class="s2">"%A, %e %B %Y, %r"</span><span class="sb">`</span><span class="s2">
</span><span class="sb">`</span><span class="nb">uname</span> <span class="nt">-srmo</span><span class="sb">`</span><span class="si">$(</span>tput setaf 1<span class="si">)</span><span class="s2">
Tiempo de actividad..: </span><span class="k">${</span><span class="nv">UPTIME</span><span class="k">}</span><span class="s2">
Memoria RAM..........: </span><span class="sb">`</span><span class="nb">cat</span> /proc/meminfo | <span class="nb">grep </span>MemFree | <span class="nb">awk</span> <span class="o">{</span><span class="s1">'print $2'</span><span class="o">}</span><span class="sb">`</span><span class="s2">kB (Free) / </span><span class="sb">`</span><span class="nb">cat</span> /proc/meminfo | <span class="nb">grep </span>MemTotal | <span class="nb">awk</span> <span class="o">{</span><span class="s1">'print $2'</span><span class="o">}</span><span class="sb">`</span><span class="s2">kB (Total)
Promedios de carga...: </span><span class="k">${</span><span class="nv">one</span><span class="k">}</span><span class="s2">, </span><span class="k">${</span><span class="nv">five</span><span class="k">}</span><span class="s2">, </span><span class="k">${</span><span class="nv">fifteen</span><span class="k">}</span><span class="s2"> (1, 5, 15 min)
Procesos activos.....: </span><span class="sb">`</span>ps ax | <span class="nb">wc</span> <span class="nt">-l</span> | <span class="nb">tr</span> <span class="nt">-d</span> <span class="s2">" "</span><span class="sb">`</span><span class="s2">
IP conexion por SSH..: </span><span class="si">$(</span><span class="nb">echo</span> <span class="nv">$SSH_CLIENT</span> | <span class="nb">awk</span> <span class="s1">'{ print $1}'</span><span class="si">)</span><span class="s2">
Temperatura Sistema..: </span><span class="si">$(</span>show_temp<span class="si">)</span><span class="s2">ºC
</span><span class="si">$(</span>tput sgr0<span class="si">)</span><span class="s2">"</span>
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y creamos el siguiente archivo:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>nano .inputrc
</code></pre></div></div>
<p>Con el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># Flecha arriba</span>
<span class="s2">"</span><span class="se">\e</span><span class="s2">[A"</span>:history-search-backward
<span class="c"># Flecha abajo</span>
<span class="s2">"</span><span class="se">\e</span><span class="s2">[B"</span>:history-search-forward
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y reiniciamos para ver los cambios.</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>reiniciar
</code></pre></div></div>
<p>Adjunto resultado de lo que veremos tras el reinicio:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Linux overclock 6.1.0-10-amd64 <span class="c">#1 SMP PREEMPT_DYNAMIC Debian 6.1.37-1 (2023-07-03) x86_64</span>
The programs included with the Debian GNU/Linux system are free software<span class="p">;</span>
the exact distribution terms <span class="k">for </span>each program are described <span class="k">in </span>the
individual files <span class="k">in</span> /usr/share/doc/<span class="k">*</span>/copyright.
Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
You have mail.
Last login: Sun Jul 15 12:00:00 2023 from 192.168.1.112
sábado, 15 julio 2023, 06:39:55
Linux 6.1.0-10-amd64 x86_64 GNU/Linux
Tiempo de actividad..: 0 dias, 00h03m47s
Memoria RAM..........: 27151572kB <span class="o">(</span>Free<span class="o">)</span> / 32831084kB <span class="o">(</span>Total<span class="o">)</span>
Promedios de carga...: 0.08, 0.09, 0.09 <span class="o">(</span>1, 5, 15 min<span class="o">)</span>
Procesos activos.....: 236
IP conexion por SSH..: 192.168.1.112
Temperatura Sistema..: 32.0ºC
pi@overclock:~<span class="err">$</span>
</code></pre></div></div>
<h2 id="redes">Redes</h2>
<p>Tras haber configurado nuestro sistema Base, vamos a configurar y segurizar nuestra red doméstica.</p>
<h3 id="identificando-red">Identificando RED</h3>
<p>La primera tarea que debemos de realizar es encontrar el nombre de nuestro identificador de red y el rango de la misma.</p>
<p>Este comando nos dara la información esperada:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>ip a
</code></pre></div></div>
<p>Y entre los valores que muestra el comando me quedo con la siguiente información:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast master state UP
group default qlen 1000
<span class="nb">link</span>/ether xx:xx:xx:xx:xx:xx brd xx:xx:xx:xx:xx:xx
inet 192.168.1.250/24 brd 192.168.1.255 scope global ens33
valid_lft forever preferred_lft forever
</code></pre></div></div>
<p>Ahora se que mi dispositivo de red cableada esta identificado como <code class="language-plaintext highlighter-rouge">ens33</code> y que la IP en mi red es <code class="language-plaintext highlighter-rouge">192.168.1.250</code> rango <a href="https://es.wikipedia.org/wiki/Protocolo_de_configuraci%C3%B3n_din%C3%A1mica_de_host" class="btn btn--inverse btn--small" target="_blank">DHCP</a></p>
<h3 id="configurando-red">Configurando RED</h3>
<p>Vamos a habilitar la <a href="https://es.wikipedia.org/wiki/Redirecci%C3%B3n_de_puertos" class="btn btn--inverse btn--small" target="_blank">redicción de puertos sobre IPv4</a> que posteriormente usaremos para entre otros configurar debidamente la VPN.</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/sysctl.conf
</code></pre></div></div>
<p>Buscamos el siguiente apartado en el documento:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#net.ipv4.ip_forward=1</span>
</code></pre></div></div>
<p>Y lo dejamos de la siguiente forma, como veras solamente has de eliminar la <strong>#</strong> inicial:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>net.ipv4.ip_forward<span class="o">=</span>1
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y pasamos a configurar una <a href="https://es.wikipedia.org/wiki/Puente_de_red" class="btn btn--inverse btn--small" target="_blank">red Bridge</a> con <a href="https://es.wikipedia.org/wiki/Direcci%C3%B3n_IP" class="btn btn--inverse btn--small" target="_blank">IP estática</a>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt-get update <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> <span class="nb">install </span>bridge-utils net-tools ifupdown <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo mv</span> /etc/network/interfaces /etc/network/interfaces.bak <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>nano /etc/network/interfaces
</code></pre></div></div>
<p>En el documento en blanco que se nos abre, lo configuro con mi nombre de red <code class="language-plaintext highlighter-rouge">ens33</code> y la ip estática que le voy a configurar <code class="language-plaintext highlighter-rouge">192.168.1.90</code>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># LO</span>
auto lo
iface lo inet loopback
<span class="c"># Interfaz ens33</span>
allow-hotplug ens33
iface ens33 inet manual
<span class="c"># Bridge</span>
auto br0
iface br0 inet static
address 192.168.1.90
netmask 255.255.255.0
network 192.168.1.0
gateway 192.168.1.1
bridge_ports ens33
bridge_stp off
bridge_fd 0
bridge_maxwait 0
<span class="c"># Bridge IPV6</span>
iface br0 inet6 auto
accept_ra 1
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y nos queda corregir un posible fallo aunque no es común, en el fichero de resolución de DNS:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo mv</span> /etc/resolv.conf /etc/resolv.conf.bak <span class="o">&&</span> <span class="se">\</span>
<span class="nb">echo</span> <span class="s2">"nameserver 1.1.1.1"</span> | <span class="nb">sudo tee</span> <span class="nt">-a</span> /etc/resolv.conf
</code></pre></div></div>
<p>Para evitar que NetworkManager entre en juego editaremos su configuración, para deshabilitar que juegue con redes configuradas:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/NetworkManager/NetworkManager.conf
</code></pre></div></div>
<p>Y dejamos el fichero con el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">[</span>main]
<span class="nv">plugins</span><span class="o">=</span>ifupdown,keyfile
<span class="nv">dns</span><span class="o">=</span>none
<span class="o">[</span>ifupdown]
<span class="nv">managed</span><span class="o">=</span><span class="nb">false</span>
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y a continuación debemos de reiniciar el servidor para aplicar los nuevos cambios producidos en el dispositivo de red:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>reboot
</code></pre></div></div>
<p>Tras reiniciar nuevamente comprobamos la nueva configuración de red:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>ip a
</code></pre></div></div>
<p>Y vemos los cambios realizados:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>3: br0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP
group default qlen 1000
<span class="nb">link</span>/ether xx:xx:xx:xx:xx:xx brd xx:xx:xx:xx:xx:xx
inet 192.168.1.90/24 brd 192.168.1.255 scope global br0
valid_lft forever preferred_lft forever</pre>
</code></pre></div></div>
<p>A partir de este momento nuestra red cableada la identificaremos con el nombre de <code class="language-plaintext highlighter-rouge">br0</code> y la IP de nuestro servidor en casa sera <code class="language-plaintext highlighter-rouge">192.168.1.90</code>.</p>
<h3 id="lordpedal-bot">@Lordpedal BOT</h3>
<p>Adicional al <a href="https://telegram.me/Lordpedal_RSS" class="btn btn--info btn--small" target="_blank">Canal de Telegram</a> donde público enlaces de interés, también dispongo en la red de un <code class="language-plaintext highlighter-rouge">BOT</code> que podeis usar para notificar eventos en vuestro sistema con ayuda de unos scripts.</p>
<p>En Telegram podeís encontrarlo con el alías <a href="https://telegram.me/Lordpedalbot" class="btn btn--success btn--small" target="_blank">@Lordpedalbot</a></p>
<p><strong>Cuando lo arranques te dará la bienvenida y te notificará el ID</strong> que tienes en la red Telegram, este <code class="language-plaintext highlighter-rouge">ID</code> debes de anotarlo, porque será una variable que uses en los scripts que modificaremos a continuación.</p>
<p class="notice--info"><strong>NOTA</strong>: El token de referencia que se va usar en los scripts no tiene validez, haz de usar tu propio bot u otro token conocido. Para ello debes de reemplazar el valor <code class="language-plaintext highlighter-rouge">289352425:AAHBCcKicDtSFaY2_Gq1brnXJ5CaGba6tMA</code> por otro.</p>
<h4 id="protección-tshh">Protección TSHH</h4>
<p>La función de este bash script es la de informarte vía Telegram de una anomalía en la temperatura del sistema y proceder a un apagado del mismo de forma controlada. Vamos a crear el script:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">mkdir</span> <span class="nt">-p</span> <span class="nv">$HOME</span>/scripts <span class="o">&&</span> <span class="se">\</span>
<span class="nb">cd</span> <span class="nv">$HOME</span>/scripts <span class="o">&&</span> <span class="se">\</span>
nano tshh.sh <span class="o">&&</span> <span class="se">\</span>
<span class="nb">chmod</span> +x tshh.sh
</code></pre></div></div>
<p>Y le agregamos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#!/bin/bash</span>
<span class="c">#</span>
<span class="c"># https://lordpedal.github.io</span>
<span class="c"># Another fine release by Lordpedal</span>
<span class="c">#</span>
<span class="c"># Fichero Log</span>
<span class="nv">data</span><span class="o">=</span><span class="sb">`</span><span class="nb">date</span><span class="sb">`</span>
<span class="nv">usu</span><span class="o">=</span><span class="sb">`</span><span class="nb">uname</span><span class="sb">`</span>
<span class="nv">ini</span><span class="o">=</span><span class="sb">`</span><span class="nb">echo</span> <span class="s2">"Script alarma de temperatura ejecutada con éxito"</span><span class="sb">`</span>
<span class="nv">rutalog</span><span class="o">=</span>/home/<span class="nv">$USER</span>
<span class="c"># ID Telegram</span>
<span class="nv">telegram</span><span class="o">=</span>79593223
<span class="c"># Temperatura máxima</span>
<span class="nv">overheat</span><span class="o">=</span>70
<span class="c"># Calcula temperatura y crea temporales de calculo</span>
sensors | <span class="nb">grep</span> <span class="nt">-oP</span> <span class="s1">'Core 0.*?\+\K[0-9]+'</span> <span class="o">></span> termopar
<span class="c"># Ejecuta alarma y aviso por telegram</span>
<span class="k">while </span><span class="nb">read </span>tempactual
<span class="k">do
if</span> <span class="o">[</span> <span class="s2">"</span><span class="nv">$tempactual</span><span class="s2">"</span> <span class="nt">-ge</span> <span class="s2">"</span><span class="nv">$overheat</span><span class="s2">"</span> <span class="o">]</span>
<span class="k">then
</span><span class="nb">echo</span> <span class="s2">"</span><span class="nv">$data</span><span class="s2"> - </span><span class="nv">$usu</span><span class="s2"> - </span><span class="nv">$ini</span><span class="s2">. Ejecutada protección de temperatura. Alcanzados </span><span class="nv">$tempactual</span><span class="s2">ºC"</span> <span class="o">>></span> <span class="nv">$rutalog</span>/tshh.log
/usr/bin/curl <span class="nt">--silent</span> <span class="nt">--output</span> /dev/null <span class="nt">--data-urlencode</span> <span class="s2">"chat_id=</span><span class="nv">$telegram</span><span class="s2">"</span> <span class="nt">--data-urlencode</span> <span class="s2">"text=Temperatura del Sistema:</span><span class="nv">$tempactual</span><span class="s2">ºC. Por seguridad ejecutado el protocolo de apagado sistema"</span> <span class="s2">"https://api.telegram.org/bot289352425:AAHBCcKicDtSFaY2_Gq1brnXJ5CaGba6tMA/sendMessage"</span>
<span class="c"># Apaga el sistema</span>
<span class="nb">sudo </span>poweroff
<span class="k">else
</span><span class="nb">echo</span> <span class="s2">"Temperatura de sistema: </span><span class="nv">$tempactual</span><span class="s2">ºC"</span>
<span class="k">fi
done</span><termopar
<span class="c"># Borra los temporales generados</span>
<span class="nb">rm </span>termopar
</code></pre></div></div>
<p class="notice--warning"><strong>NOTA:</strong> Recuerda que el valor del <code class="language-plaintext highlighter-rouge">ID de Telegram</code> debes de <strong>sustituirlo por el tuyo propio</strong> y el valor <code class="language-plaintext highlighter-rouge">overheat cambialo</code> según rangos de temperatura de tu procesador obtenido tras ejecutar: <code class="language-plaintext highlighter-rouge">sensors</code>, en mi caso el rango que obtenía era de (high = +84.0°C, crit = +100.0°C) por eso defino <code class="language-plaintext highlighter-rouge">70°C</code> como valor más conservador.</p>
<p>Guardamos los cambios, salimos del editor de texto y programamos el sistema para que el script sea ejecutado cada <code class="language-plaintext highlighter-rouge">15 segundos</code>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>crontab <span class="nt">-e</span>
</code></pre></div></div>
<p>Y añadimos al final el fichero, recuerda sustituir <code class="language-plaintext highlighter-rouge">pi</code> por tu usuario:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="nb">sleep </span>15 <span class="o">&&</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="nb">sleep </span>30 <span class="o">&&</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="nb">sleep </span>45 <span class="o">&&</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y listo ya tendriamos la protección activa. El fichero en mi caso queda de la siguiente forma:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@overclock:~<span class="nv">$ </span>crontab <span class="nt">-l</span>
<span class="c"># Edit this file to introduce tasks to be run by cron.</span>
<span class="c">#</span>
<span class="c"># Each task to run has to be defined through a single line</span>
<span class="c"># indicating with different fields when the task will be run</span>
<span class="c"># and what command to run for the task</span>
<span class="c">#</span>
<span class="c"># To define the time you can provide concrete values for</span>
<span class="c"># minute (m), hour (h), day of month (dom), month (mon),</span>
<span class="c"># and day of week (dow) or use '*' in these fields (for 'any').#</span>
<span class="c"># Notice that tasks will be started based on the cron's system</span>
<span class="c"># daemon's notion of time and timezones.</span>
<span class="c">#</span>
<span class="c"># Output of the crontab jobs (including errors) is sent through</span>
<span class="c"># email to the user the crontab file belongs to (unless redirected).</span>
<span class="c">#</span>
<span class="c"># For example, you can run a backup of all your user accounts</span>
<span class="c"># at 5 a.m every week with:</span>
<span class="c"># 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/</span>
<span class="c">#</span>
<span class="c"># For more information see the manual pages of crontab(5) and cron(8)</span>
<span class="c">#</span>
<span class="c"># m h dom mon dow command</span>
<span class="c">#</span>
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="nb">sleep </span>15 <span class="o">&&</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="nb">sleep </span>30 <span class="o">&&</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="nb">sleep </span>45 <span class="o">&&</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
</code></pre></div></div>
<h4 id="notificación-arranque-servidor">Notificación Arranque Servidor</h4>
<p>La función de este bash script es la de informarte vía Telegram de que el Servidor esta online. Vamos a crear el script:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">mkdir</span> <span class="nt">-p</span> <span class="nv">$HOME</span>/scripts <span class="o">&&</span> <span class="se">\</span>
<span class="nb">cd</span> <span class="nv">$HOME</span>/scripts <span class="o">&&</span> <span class="se">\</span>
nano overspeed.sh <span class="o">&&</span> <span class="se">\</span>
<span class="nb">chmod</span> +x overspeed.sh
</code></pre></div></div>
<p>Y le agregamos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#!/bin/bash</span>
<span class="c">#</span>
<span class="c"># https://lordpedal.github.io</span>
<span class="c"># Another fine release by Lordpedal</span>
<span class="c">#</span>
<span class="c"># ID Telegram</span>
<span class="nv">telegram</span><span class="o">=</span>79593223
<span class="c"># Mensaje Online</span>
<span class="nv">mensaje</span><span class="o">=</span><span class="s1">'Overclock Server Online ... Another fine release by Lordpedal'</span>
<span class="c"># Inicia bucle chequeo de Red</span>
<span class="k">while </span><span class="nb">true
</span><span class="k">do</span>
<span class="c"># Comprueba disponibilidad de Red</span>
<span class="k">if </span>ping <span class="nt">-c</span> 1 <span class="nt">-W</span> 5 google.com 1>/dev/null 2>&1
<span class="k">then</span>
<span class="c"># Red disponible</span>
<span class="nb">echo</span> <span class="s2">"Conexion establecida..."</span>
/usr/bin/curl <span class="nt">--silent</span> <span class="se">\</span>
<span class="nt">--output</span> /dev/null <span class="se">\</span>
<span class="nt">--data-urlencode</span> <span class="s2">"chat_id=</span><span class="nv">$telegram</span><span class="s2">"</span> <span class="se">\</span>
<span class="nt">--data-urlencode</span> <span class="s2">"text=</span><span class="nv">$mensaje</span><span class="s2">"</span> <span class="se">\</span>
<span class="s2">"https://api.telegram.org/bot289352425:AAHBCcKicDtSFaY2_Gq1brnXJ5CaGba6tMA/sendMessage"</span>
<span class="c"># Termina bucle disponibilidad de Red</span>
<span class="nb">break
</span><span class="k">else</span>
<span class="c"># Red no disponible</span>
<span class="nb">echo</span> <span class="s2">"Conexion no establecida..."</span>
<span class="k">fi</span>
<span class="c"># Espera 1s y reinicia bucle</span>
<span class="nb">sleep </span>1
<span class="k">done</span>
</code></pre></div></div>
<p class="notice--warning"><strong>NOTA:</strong> Recuerda que el valor del <code class="language-plaintext highlighter-rouge">ID de Telegram</code> debes de <strong>sustituirlo por el tuyo propio</strong> y el valor <code class="language-plaintext highlighter-rouge">mensaje</code> cambialo por tu mensaje personalizado.</p>
<p>Guardamos los cambios, salimos del editor de texto y programamos el sistema para que el script sea ejecutado tras reinicio de sistema y disponibilidad de red:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>crontab <span class="nt">-e</span>
</code></pre></div></div>
<p>Y añadimos al final el fichero, recuerda sustituir <code class="language-plaintext highlighter-rouge">pi</code> por tu usuario:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>@reboot /home/pi/scripts/overspeed.sh <span class="o">></span>/dev/null 2>&1
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y listo ya tendriamos la notificación activa. El fichero en mi caso queda de la siguiente forma:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@overclock:~<span class="nv">$ </span>crontab <span class="nt">-l</span>
<span class="c"># Edit this file to introduce tasks to be run by cron.</span>
<span class="c">#</span>
<span class="c"># Each task to run has to be defined through a single line</span>
<span class="c"># indicating with different fields when the task will be run</span>
<span class="c"># and what command to run for the task</span>
<span class="c">#</span>
<span class="c"># To define the time you can provide concrete values for</span>
<span class="c"># minute (m), hour (h), day of month (dom), month (mon),</span>
<span class="c"># and day of week (dow) or use '*' in these fields (for 'any').#</span>
<span class="c"># Notice that tasks will be started based on the cron's system</span>
<span class="c"># daemon's notion of time and timezones.</span>
<span class="c">#</span>
<span class="c"># Output of the crontab jobs (including errors) is sent through</span>
<span class="c"># email to the user the crontab file belongs to (unless redirected).</span>
<span class="c">#</span>
<span class="c"># For example, you can run a backup of all your user accounts</span>
<span class="c"># at 5 a.m every week with:</span>
<span class="c"># 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/</span>
<span class="c">#</span>
<span class="c"># For more information see the manual pages of crontab(5) and cron(8)</span>
<span class="c">#</span>
<span class="c"># m h dom mon dow command</span>
<span class="c">#</span>
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="nb">sleep </span>15 <span class="o">&&</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="nb">sleep </span>30 <span class="o">&&</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
<span class="k">*</span>/1 <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="k">*</span> <span class="nb">sleep </span>45 <span class="o">&&</span> /home/pi/scripts/tshh.sh <span class="o">></span>/dev/null 2>&1
@reboot /home/pi/scripts/overspeed.sh <span class="o">></span>/dev/null 2>&1
</code></pre></div></div>
<h3 id="p3dns">P3DNS</h3>
<p>Es un docker-compose que integra las siguientes herramientas:</p>
<ul>
<li>
<p><code class="language-plaintext highlighter-rouge">Pi-hole</code>: Aplicación centrada en <strong>bloqueo de publicidad y entornos maliciosos de la red</strong>.</p>
</li>
<li>
<p><code class="language-plaintext highlighter-rouge">DNScrypt-Proxy</code>: Aplicación <strong>proxy de cifrado mediante diferentes protocolos de criptografía</strong> de las peticiones DNS.</p>
</li>
<li>
<p><code class="language-plaintext highlighter-rouge">Cloudflared</code>: Aplicación de <strong>cifrado DoH (DNS over HTTPS)</strong> de las peticiones DNS.</p>
</li>
</ul>
<p>Antes de continuar debemos de realizar estos pasos:</p>
<ol>
<li>Instalamos y configuramos: <a href="https://lordpedal.github.io/gnu/linux/docker/debian-docker-ce/#instalaci%C3%B3n-amd64" class="btn btn--success btn--small" target="_blank">Docker</a></li>
<li>Configuramos e instalamos: <a href="https://lordpedal.github.io/gnu/linux/docker/debian-docker-ce/#docker-p3dns" class="btn btn--success btn--small" target="_blank">P3DNS</a></li>
</ol>
<h3 id="configurando-dns-pública">Configurando DNS Pública</h3>
<p>Como sabras tu <strong>IP doméstica no es tu IP pública</strong> y al igual que en un comienzo tu IP doméstica era DHCP lo mismo ocurre con la IP pública. Por tanto para poder redireccionar servicios, necesitamos disponer de IP pública estática.
La forma más sencilla es usar un proveedor de DNS públicas de calidad como por ejemplo <a href="https://www.duckdns.org/" class="btn btn--inverse btn--small" target="_blank">DuckDNS</a></p>
<p>Entramos en la <a href="https://www.duckdns.org/" class="btn btn--inverse btn--small" target="_blank">web</a> y creamos una <em>cuenta gratuita</em> en la cual registraremos nuestro <em>dominio</em>, ejemplo: <strong>lordpedal.duckdns.org</strong>.</p>
<p>Adjunto enlace tutorial oficial:</p>
<p><a href="https://www.duckdns.org/install.jsp#linux-cron" class="btn btn--inverse btn--small" target="_blank">Tutorial de configuración en GNU/Linux vía programador de tareas cron</a></p>
<p>Aunque recomiendo usar la versión <a href="https://lordpedal.github.io/gnu/linux/docker/duckdns-docker/" class="btn btn--success btn--small" target="_blank">Docker: DuckDNS</a> publicada en este blog.</p>
<p>Luego tenemos que configurar nuestro hosts para agregar nuestra DNS Pública:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/hosts
</code></pre></div></div>
<p>Buscamos la línea:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>127.0.0.1 localhost
</code></pre></div></div>
<p>Y la modificamos con nuestra cuenta en DuckDNS:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>127.0.0.1 localhost lordpedal.duckdns.org
</code></pre></div></div>
<p>Guardamos los cambios y salimos del editor de texto.</p>
<h3 id="vpns">VPN´s</h3>
<p>Una red privada virtual es una tecnología de red de ordenadores que permite una extensión segura de la red de área local sobre una red pública o no controlada como Internet.
Permite que el ordenador en la red envíe y reciba datos sobre redes compartidas o públicas como si fuera una red privada, con toda la funcionalidad, seguridad y políticas de gestión de una red privada.
Esto se realiza estableciendo una conexión virtual punto a punto mediante el uso de conexiones dedicadas, cifrado o la combinación de ambos métodos.</p>
<h4 id="wireguard-recomendada">Wireguard (Recomendada)</h4>
<p><a href="https://lordpedal.github.io/gnu/linux/docker/debian-docker-ce/#docker-wireguard" class="btn btn--success btn--small" target="_blank">Ampliar información en esta entrada</a></p>
<h4 id="openvpn-opcional">OpenVPN (Opcional)</h4>
<p>Teniendo ya fijada una DNS Pública, una IP estática interna y la redirección de puertos, ya podemos proceder a configurar de forma sencilla el acceso mediante <a href="https://es.wikipedia.org/wiki/Red_privada_virtual" class="btn btn--inverse btn--small" target="_blank">VPN</a></p>
<p>Vamos a bajar un cliente asistente donde configuramemos nuestra red VPN:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> ~/ <span class="o">&&</span> <span class="se">\</span>
wget https://git.io/vpn <span class="nt">-O</span> openvpn-install.sh <span class="o">&&</span> <span class="se">\</span>
<span class="nb">chmod </span>755 openvpn-install.sh <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo</span> ./openvpn-install.sh
</code></pre></div></div>
<p>Durante la instalación nos solicitara unos parametros de nuestros pasos previos:</p>
<ul>
<li>IPv4 (automatically detected, if not enter the local IPv4 address): <code class="language-plaintext highlighter-rouge">192.168.1.90</code></li>
<li>Public IP (enter your public IP address): <code class="language-plaintext highlighter-rouge">lordpedal.duckdns.org</code></li>
<li>Protocol: <code class="language-plaintext highlighter-rouge">UDP</code></li>
<li>Port (change to your desired port): <code class="language-plaintext highlighter-rouge">2194</code></li>
<li>DNS: <code class="language-plaintext highlighter-rouge">Current system resolvers</code></li>
<li>Client name: <code class="language-plaintext highlighter-rouge">Lordpedal</code></li>
</ul>
<p>Vamos a afinar la configuración de la VPN con capas extras de personalización, ahora debemos de conocer la IP de la nuestra red virtual <strong>TUN0</strong></p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>ifconfig tun0 | <span class="nb">grep</span> <span class="s1">'inet'</span>
</code></pre></div></div>
<p>En mi caso el valor de referencia es: <code class="language-plaintext highlighter-rouge">10.8.0.1</code>. Vamos a editar la configuración del servidor de <a href="https://es.wikipedia.org/wiki/OpenVPN" class="btn btn--inverse btn--small" target="_blank">OpenVPN</a></p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/openvpn/server/server.conf
</code></pre></div></div>
<p>Buscamos la linea donde el codigo empieza por (suele ser una única línea en según que casos alguna duplicada):</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>push <span class="s2">"dhcp-option DNS
</span></code></pre></div></div>
<p>Y sustituimos la linea o si existen varias dejamos una sola que haga referencia al codigo push dhcp-option con lo siguiente:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>push <span class="s2">"dhcp-option DNS 10.8.0.1"</span>
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y reiniciamos el servicio OpenVPN:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>systemctl restart openvpn
</code></pre></div></div>
<p>Recordad que el fichero OVPN generado en nuestro caso se llamaba Lordpedal lo tendremos que pasar a nuestra carpeta de usuario.</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo cp</span> /root/Lordpedal.ovpn /home/pi <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo chown </span>pi:pi /home/pi/Lordpedal.ovpn
</code></pre></div></div>
<p>Ahora ya podremos pasar el fichero OVPN a nuestro Smartphone/Tablet/Pendrive/… para poder conectarnos en remoto previa configuración router.
Recuerda abrir el <strong>Puerto</strong> <code class="language-plaintext highlighter-rouge">2194</code> a la <strong>IP</strong> <code class="language-plaintext highlighter-rouge">192.168.1.90</code> con <strong>Protocolo</strong> <code class="language-plaintext highlighter-rouge">UDP</code> si has seguido la configuración que detallo paso a paso.</p>
<h3 id="ssh">SSH</h3>
<p><a href="https://es.wikipedia.org/wiki/SSH" class="btn btn--inverse btn--small" target="_blank">SSH</a> es un protocolo de comunicación que encripta los datos que se intercambian, y es virtualmente imposible romper la privacidad de la comunicación. El acrónimo ssh viene del inglés: Secure SHell.</p>
<p>El protocolo ssh es muy versátil, tiene un software cliente que posibilita el acceso a la línea de comandos, permite la transferencia de archivos y la creación de túneles seguros con soporte de comunicación para otros protocolos.</p>
<p>Los clientes ssh se dividen en dos grupos:</p>
<ul>
<li>Terminal SSH Es un emulador de terminal que permite acceder de forma remota desde un equipo a la línea de comandos del equipo remoto, utilizando el protocolo SSH.</li>
<li>Cliente SFTP Se trata de un cliente para transferencia de archivos que utiliza el Protocolo de Transferencia Segura de Archivos. Sus siglas significan en inglés (Secure File Transfer Protocol (SFTP)</li>
</ul>
<p>Entrando en materia, si durante la instalación de Debian no <a href="http://www.openssh.com/" class="btn btn--inverse btn--small" target="_blank">instalamos SSH</a> podemos activarlo de la siguiente forma:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>instalar openssh-server openssh-client
</code></pre></div></div>
<p>Realizado este punto o ya instalado anteriormente, sabemos que remotamente podremos acceder a nuestro Server desde nuestra red local con el siguiente comando, <em>recuerda sustituir usuario</em> <code class="language-plaintext highlighter-rouge">pi</code> <em>e</em> <code class="language-plaintext highlighter-rouge">ip</code> <em>por tus datos</em>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>ssh pi@192.168.1.90
</code></pre></div></div>
<p>Pero recomiendo dar un paso más en la seguridad de nuestro sistema, por ello ahora nos toca securizarlo en la medida de la posible <strong>cambiando puerto por defecto 22, usuario root, …</strong></p>
<p>Para ello editaremos el fichero de configuración SSH:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/ssh/sshd_config
</code></pre></div></div>
<p>Adjunto mi fichero de configuración con los <code class="language-plaintext highlighter-rouge">mods de seguridad activos</code>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># This is the sshd server system-wide configuration file. See</span>
<span class="c"># sshd_config(5) for more information.</span>
<span class="c"># This sshd was compiled with PATH=/usr/bin:/bin:/usr/sbin:/sbin</span>
<span class="c"># The strategy used for options in the default sshd_config shipped with</span>
<span class="c"># OpenSSH is to specify options with their default value where</span>
<span class="c"># possible, but leave them commented. Uncommented options override the</span>
<span class="c"># default value.</span>
Port 69
<span class="c">#AddressFamily any</span>
<span class="c">#ListenAddress 0.0.0.0</span>
<span class="c">#ListenAddress ::</span>
<span class="c">#HostKey /etc/ssh/ssh_host_rsa_key</span>
<span class="c">#HostKey /etc/ssh/ssh_host_ecdsa_key</span>
<span class="c">#HostKey /etc/ssh/ssh_host_ed25519_key</span>
<span class="c"># Ciphers and keying</span>
<span class="c">#RekeyLimit default none</span>
<span class="c"># Logging</span>
SyslogFacility AUTH
LogLevel INFO
<span class="c"># Authentication:</span>
LoginGraceTime 2m
PermitRootLogin no
<span class="c">#StrictModes yes</span>
MaxAuthTries 3
MaxSessions 5
<span class="c">#PubkeyAuthentication yes</span>
<span class="c"># Expect .ssh/authorized_keys2 to be disregarded by default in future.</span>
<span class="c">#AuthorizedKeysFile .ssh/authorized_keys .ssh/authorized_keys2</span>
<span class="c">#AuthorizedPrincipalsFile none</span>
<span class="c">#AuthorizedKeysCommand none</span>
<span class="c">#AuthorizedKeysCommandUser nobody</span>
<span class="c"># For this to work you will also need host keys in /etc/ssh/ssh_known_hosts</span>
<span class="c">#HostbasedAuthentication no</span>
<span class="c"># Change to yes if you don't trust ~/.ssh/known_hosts for</span>
<span class="c"># HostbasedAuthentication</span>
<span class="c">#IgnoreUserKnownHosts no</span>
<span class="c"># Don't read the user's ~/.rhosts and ~/.shosts files</span>
<span class="c">#IgnoreRhosts yes</span>
<span class="c"># To disable tunneled clear text passwords, change to no here!</span>
<span class="c">#PasswordAuthentication yes</span>
PermitEmptyPasswords no
<span class="c"># Change to yes to enable challenge-response passwords (beware issues with</span>
<span class="c"># some PAM modules and threads)</span>
ChallengeResponseAuthentication no
<span class="c"># Kerberos options</span>
<span class="c">#KerberosAuthentication no</span>
<span class="c">#KerberosOrLocalPasswd yes</span>
<span class="c">#KerberosTicketCleanup yes</span>
<span class="c">#KerberosGetAFSToken no</span>
<span class="c"># GSSAPI options</span>
<span class="c">#GSSAPIAuthentication no</span>
<span class="c">#GSSAPICleanupCredentials yes</span>
<span class="c">#GSSAPIStrictAcceptorCheck yes</span>
<span class="c">#GSSAPIKeyExchange no</span>
<span class="c"># Set this to 'yes' to enable PAM authentication, account processing,</span>
<span class="c"># and session processing. If this is enabled, PAM authentication will</span>
<span class="c"># be allowed through the ChallengeResponseAuthentication and</span>
<span class="c"># PasswordAuthentication. Depending on your PAM configuration,</span>
<span class="c"># PAM authentication via ChallengeResponseAuthentication may bypass</span>
<span class="c"># the setting of "PermitRootLogin without-password".</span>
<span class="c"># If you just want the PAM account and session checks to run without</span>
<span class="c"># PAM authentication, then enable this but set PasswordAuthentication</span>
<span class="c"># and ChallengeResponseAuthentication to 'no'.</span>
UsePAM <span class="nb">yes</span>
<span class="c">#AllowAgentForwarding yes</span>
<span class="c">#AllowTcpForwarding yes</span>
<span class="c">#GatewayPorts no</span>
X11Forwarding <span class="nb">yes</span>
<span class="c">#X11DisplayOffset 10</span>
<span class="c">#X11UseLocalhost yes</span>
<span class="c">#PermitTTY yes</span>
PrintMotd no
<span class="c">#PrintLastLog yes</span>
<span class="c">#TCPKeepAlive yes</span>
<span class="c">#UseLogin no</span>
<span class="c">#UsePrivilegeSeparation sandbox</span>
<span class="c">#PermitUserEnvironment no</span>
<span class="c">#Compression delayed</span>
<span class="c">#ClientAliveInterval 0</span>
<span class="c">#ClientAliveCountMax 3</span>
<span class="c">#UseDNS no</span>
<span class="c">#PidFile /var/run/sshd.pid</span>
<span class="c">#MaxStartups 10:30:100</span>
<span class="c">#PermitTunnel no</span>
<span class="c">#ChrootDirectory none</span>
<span class="c">#VersionAddendum none</span>
<span class="c"># no default banner path</span>
<span class="c">#Banner none</span>
<span class="c"># Allow client to pass locale environment variables</span>
AcceptEnv LANG LC_<span class="k">*</span>
<span class="c"># override default of no subsystems</span>
Subsystem sftp /usr/lib/openssh/sftp-server
<span class="c"># Example of overriding settings on a per-user basis</span>
<span class="c">#Match User anoncvs</span>
<span class="c"># X11Forwarding no</span>
<span class="c"># AllowTcpForwarding no</span>
<span class="c"># PermitTTY no</span>
<span class="c"># ForceCommand cvs server</span>
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y reiniciamos el servicio:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>systemctl restart ssh
</code></pre></div></div>
<p>Y a partir de este momento para conectarnos por SSH lo haremos de la siguiente forma:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>ssh pi@192.168.1.90 <span class="nt">-p</span> 69
</code></pre></div></div>
<h4 id="fail2ban">Fail2BAN</h4>
<p><code class="language-plaintext highlighter-rouge">Fail2ban</code> es una <strong>herramienta de seguridad escrita en Python</strong> fundamental para cualquier servidor.</p>
<p>La principal función de <a href="https://www.fail2ban.org/wiki/index.php/Main_Page" class="btn btn--inverse btn--small" target="_blank">Fail2ban</a> es securizar un servidor del siguiente modo:</p>
<ol>
<li>Evitando accesos indeseados a nuestro equipo o servidor.</li>
<li>Evitando ataques de fuerza bruta para que un tercero averigüe nuestra contraseña o tumbe el servidor.</li>
</ol>
<p>Por un lado está monitorizando las autenticaciones que una determinada IP hace a un determinado/s puerto/s y servicio/s. Para ello está consultando permanente los logs de autenticación de nuestro sistema como por ejemplo el <strong>/var/log/auth.log</strong>. Vamos a proceder a instalarlo:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt-get update <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> <span class="nb">install </span>fail2ban
</code></pre></div></div>
<p>Una vez instalado vamos a configurarlo:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> /etc/fail2ban <span class="o">&&</span> <span class="nb">sudo </span>nano jail.conf
</code></pre></div></div>
<p>Adjunto a modo resumen las opciones a buscar y modificar:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>ignoreip <span class="o">=</span> 127.0.0.1/8
bantime <span class="o">=</span> 600
maxretry <span class="o">=</span> 5
</code></pre></div></div>
<p>Y segundo como las dejaremos, <strong>en mi caso la IP es de rango</strong> <code class="language-plaintext highlighter-rouge">192.168.1.0</code>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>ignoreip <span class="o">=</span> 127.0.0.1/8 192.168.1.0/24
bantime <span class="o">=</span> 3600
maxretry <span class="o">=</span> 3
</code></pre></div></div>
<p>Una vez finalizada la edición, guardaremos los cambios, saldremos del editor de texto y lo activaremos en local:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo cp</span> /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
</code></pre></div></div>
<p>Ahora vamos a crear una configuración específica para aprovecharnos de notificaciones vía Telegram:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> /etc/fail2ban/action.d <span class="o">&&</span> <span class="nb">sudo </span>nano telegram.conf
</code></pre></div></div>
<p>Y le agregamos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># Fail2Ban configuration file</span>
<span class="c">#</span>
<span class="c"># Author: Lordpedal</span>
<span class="c">#</span>
<span class="o">[</span>Definition]
<span class="c"># Option: actionstart</span>
<span class="c"># Notes.: command executed once at the start of Fail2Ban.</span>
<span class="c"># Values: CMD</span>
<span class="c">#</span>
actionstart <span class="o">=</span> /etc/fail2ban/scripts/fail2ban-telegram.sh start
<span class="c"># Option: actionstop</span>
<span class="c"># Notes.: command executed once at the end of Fail2Ban</span>
<span class="c"># Values: CMD</span>
<span class="c">#</span>
actionstop <span class="o">=</span> /etc/fail2ban/scripts/fail2ban-telegram.sh stop
<span class="c"># Option: actioncheck</span>
<span class="c"># Notes.: command executed once before each actionban command</span>
<span class="c"># Values: CMD</span>
<span class="c">#</span>
actioncheck <span class="o">=</span>
<span class="c"># Option: actionban</span>
<span class="c"># Notes.: command executed when banning an IP. Take care that the</span>
<span class="c"># command is executed with Fail2Ban user rights.</span>
<span class="c"># Tags: See jail.conf(5) man page</span>
<span class="c"># Values: CMD</span>
<span class="c">#</span>
actionban <span class="o">=</span> /etc/fail2ban/scripts/fail2ban-telegram.sh ban <ip>
<span class="c"># Option: actionunban</span>
<span class="c"># Notes.: command executed when unbanning an IP. Take care that the</span>
<span class="c"># command is executed with Fail2Ban user rights.</span>
<span class="c"># Tags: See jail.conf(5) man page</span>
<span class="c"># Values: CMD</span>
<span class="c">#</span>
actionunban <span class="o">=</span> /etc/fail2ban/scripts/fail2ban-telegram.sh unban <ip>
<span class="o">[</span>Init]
init <span class="o">=</span> 21121981
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y crearemos el script de notificación:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> /etc/fail2ban <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo mkdir </span>scripts <span class="o">&&</span> <span class="se">\</span>
<span class="nb">cd </span>scripts <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>nano fail2ban-telegram.sh <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo chmod</span> +x fail2ban-telegram.sh
</code></pre></div></div>
<p>Agregamos el siguiente bash script:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#!/bin/bash</span>
<span class="c">#</span>
<span class="c"># https://lordpedal.github.io</span>
<span class="c"># Another fine release by Lordpedal</span>
<span class="c">#</span>
<span class="k">while </span><span class="nb">true
</span><span class="k">do
if </span>ping <span class="nt">-c</span> 1 <span class="nt">-W</span> 3 google.com 1>/dev/null 2>&1
<span class="k">then
</span><span class="nb">echo</span> <span class="s2">""</span>
<span class="nb">break
</span><span class="k">else
</span><span class="nb">echo</span> <span class="s2">""</span>
<span class="k">fi
</span><span class="nb">sleep </span>1
<span class="k">done</span>
<span class="c"># Opciones ejecucion</span>
<span class="nv">info</span><span class="o">=</span><span class="sb">`</span><span class="nb">hostname</span> <span class="nt">-f</span><span class="sb">`</span>
<span class="k">function </span>show_uso <span class="o">{</span>
<span class="nb">echo</span> <span class="s2">"Fail2ban Telegram by Lordpedal"</span>
<span class="nb">echo</span> <span class="s2">""</span>
<span class="nb">echo</span> <span class="s2">"Usar: </span><span class="nv">$0</span><span class="s2"> opcion <ip>"</span>
<span class="nb">echo</span> <span class="s2">""</span>
<span class="nb">echo</span> <span class="s2">"Opcion: start (Inicia notificaciones)"</span>
<span class="nb">echo</span> <span class="s2">" stop (Detiene notificaciones)"</span>
<span class="nb">echo</span> <span class="s2">" ban <ip> (Banea IP especificada) Ej: ban 192.168.1.2"</span>
<span class="nb">echo</span> <span class="s2">" unban <ip> (Desbanea IP especificada) Ej: unban 192.168.1.2"</span>
<span class="nb">echo</span> <span class="s2">""</span>
<span class="nb">exit</span>
<span class="o">}</span>
<span class="c"># Notificacion</span>
<span class="k">function </span>send_msg <span class="o">{</span>
<span class="c"># ID Telegram</span>
<span class="nv">telegram</span><span class="o">=</span>79593223
<span class="c"># Enlace BOT</span>
<span class="nv">url</span><span class="o">=</span><span class="s2">"https://api.telegram.org/bot289352425:AAHBCcKicDtSFaY2_Gq1brnXJ5CaGba6tMA/sendMessage"</span>
<span class="c"># Envia mensaje</span>
curl <span class="nt">-s</span> <span class="nt">-X</span> POST <span class="nv">$url</span> <span class="nt">-d</span> <span class="nv">chat_id</span><span class="o">=</span><span class="nv">$telegram</span> <span class="nt">-d</span> <span class="nv">text</span><span class="o">=</span><span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span>
<span class="nb">exit</span>
<span class="o">}</span>
<span class="c"># Chequea argumentos de script</span>
<span class="k">if</span> <span class="o">[</span> <span class="nv">$# </span><span class="nt">-lt</span> 1 <span class="o">]</span>
<span class="k">then
</span>show_uso
<span class="k">fi</span>
<span class="c"># Ejecuta una accion depende del argumento</span>
<span class="k">if</span> <span class="o">[</span> <span class="nv">$# </span><span class="nt">-lt</span> 1 <span class="o">]</span>
<span class="k">then
</span>show_uso
<span class="k">fi</span>
<span class="c"># Ejecuta una accion depende del argumento</span>
<span class="k">if</span> <span class="o">[</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span> <span class="o">=</span> <span class="s1">'start'</span> <span class="o">]</span>
<span class="k">then
</span><span class="nv">msg</span><span class="o">=</span><span class="s2">"Seguridad+Fail2ban+ha+sido+iniciada+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span>
send_msg <span class="nv">$msg</span>
<span class="k">elif</span> <span class="o">[</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span> <span class="o">=</span> <span class="s1">'stop'</span> <span class="o">]</span>
<span class="k">then
</span><span class="nv">msg</span><span class="o">=</span><span class="s2">"Seguridad+Fail2ban+ha+sido+detenida+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span>
send_msg <span class="nv">$msg</span>
<span class="k">elif</span> <span class="o">[</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span> <span class="o">=</span> <span class="s1">'ban'</span> <span class="o">]</span>
<span class="k">then
</span><span class="nv">msg</span><span class="o">=</span><span class="si">$(</span><span class="o">[</span> <span class="s2">"</span><span class="nv">$2</span><span class="s2">"</span> <span class="o">!=</span> <span class="s1">''</span> <span class="o">]</span> <span class="o">&&</span> <span class="nb">echo</span> <span class="s2">"Seguridad+Fail2ban+ha+baneado+a+</span><span class="nv">$2</span><span class="s2">+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span> <span class="o">||</span> <span class="nb">echo</span> <span class="s2">"Seguridad+Fail2ban+ha+baneado+una+ip+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span> <span class="si">)</span>
send_msg <span class="nv">$msg</span>
<span class="k">elif</span> <span class="o">[</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span> <span class="o">=</span> <span class="s1">'unban'</span> <span class="o">]</span>
<span class="k">then
</span><span class="nv">msg</span><span class="o">=</span><span class="si">$(</span><span class="o">[</span> <span class="s2">"</span><span class="nv">$2</span><span class="s2">"</span> <span class="o">!=</span> <span class="s1">''</span> <span class="o">]</span> <span class="o">&&</span> <span class="nb">echo</span> <span class="s2">"Seguridad+Fail2ban+ha+desbaneado+a+</span><span class="nv">$2</span><span class="s2">+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span> <span class="o">||</span> <span class="nb">echo</span> <span class="s2">"Seguridad+Fail2ban+ha+desbaneado+una+ip+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span> <span class="si">)</span>
send_msg <span class="nv">$msg</span>
<span class="k">else
</span>show_uso
<span class="k">fi</span>
</code></pre></div></div>
<p class="notice--warning"><strong>NOTA:</strong> Recuerda que el valor del <code class="language-plaintext highlighter-rouge">ID de Telegram</code> debes de sustituirlo por el tuyo propio.</p>
<p>Ahora vamos a finalizar la activación de <code class="language-plaintext highlighter-rouge">ssh</code>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> /etc/fail2ban/jail.d <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>nano jail-debian.local
</code></pre></div></div>
<p>Y le agregamos el siguiente contenido, recordemos que el puerto SSH que definimos anteriormente fue <code class="language-plaintext highlighter-rouge">69</code>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">[</span>sshd]
port <span class="o">=</span> 69
filter <span class="o">=</span> sshd
action <span class="o">=</span> iptables[name<span class="o">=</span>SSH, <span class="nv">port</span><span class="o">=</span>69, <span class="nv">protocol</span><span class="o">=</span>tcp]
telegram
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y reiniciamos Fail2ban para activar los cambios realizados:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>systemctl restart fail2ban
</code></pre></div></div>
<h2 id="multimedia">Multimedia</h2>
<p>Continuamos añadiendole extras a nuestro Servidor esta vez desde el punto <code class="language-plaintext highlighter-rouge">multimedia</code>.</p>
<h3 id="transmission">Transmission</h3>
<p><a href="https://lordpedal.github.io/gnu/linux/docker/debian-docker-ce/#docker-transmission" class="btn btn--success btn--small" target="_blank">Ampliar información en esta entrada</a></p>
<h3 id="samba">Samba</h3>
<p><a href="https://lordpedal.github.io/gnu/linux/docker/samba-docker/" class="btn btn--success btn--small" target="_blank">Ampliar información en esta entrada</a></p>
<h3 id="vnc">VNC</h3>
<p>Como tenemos instalado un <strong>entorno gráfico</strong> en el Servidor puede ser interesante controlarlo de forma remota mediante <code class="language-plaintext highlighter-rouge">VNC</code>.</p>
<p><strong>VNC</strong> (inglés: Virtual Network Computing), es también llamado software de escritorio remoto, no impone restricciones en el sistema operativo del ordenador servidor con respecto al del cliente: es posible compartir la pantalla de una máquina con cualquier sistema operativo que soporte VNC conectándose desde otro ordenador o dispositivo que disponga de un cliente VNC portado.</p>
<p>Vamos a actualizar repositorios e instalar el servidor de VNC:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt update <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> <span class="nb">install </span>tightvncserver
</code></pre></div></div>
<p>Cuando termine la instalación lanzamos el programa para generar la configuración en nuestro sistema:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>vncserver
</code></pre></div></div>
<p>Nos solicitara la creación de una contraseña y su posterior check:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Output
You will require a password to access your desktops.
Password: <span class="k">*****</span>
Verify: <span class="k">*****</span>
</code></pre></div></div>
<p>Nos preguntara si queremos crear un password de visualización solo, la respuesta será <code class="language-plaintext highlighter-rouge">n</code>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Would you like to enter a view-only password <span class="o">(</span>y/n<span class="o">)</span>? n
</code></pre></div></div>
<p>Y nos informara que ha creado la configuración necesaria en nuestra carpeta de usuario:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>xauth: file /home/pi/.Xauthority does not exist
New <span class="s1">'X'</span> desktop is your_hostname:1
Creating default startup script /home/pi/.vnc/xstartup
Starting applications specified <span class="k">in</span> /home/pi/.vnc/xstartup
Log file is /home/pi/.vnc/lordpedal:1.log
</code></pre></div></div>
<p>Para configurar el Servidor de VNC en nuestro Servidor tenemos que detener el programa en ejecución:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>vncserver <span class="nt">-kill</span> :1
</code></pre></div></div>
<p>Hacemos un backup del fichero <code class="language-plaintext highlighter-rouge">xstartup</code> generado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">mv</span> ~/.vnc/xstartup ~/.vnc/xstartup.bak
</code></pre></div></div>
<p>Vamos a crear el nuestro, personalizarlo y darle permisos de ejecución:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>nano ~/.vnc/xstartup <span class="o">&&</span> <span class="se">\</span>
<span class="nb">chmod</span> +x ~/.vnc/xstartup
</code></pre></div></div>
<p>Y dentro del fichero anexamos la siguiente configuración (Escritorio MATE):</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#!/bin/bash</span>
xrdb <span class="nv">$HOME</span>/.Xresources
xsetroot <span class="nt">-solid</span> grey
<span class="nb">export </span><span class="nv">XKL_XMODMAP_DISABLE</span><span class="o">=</span>1
/usr/bin/mate-session &
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y ahora vamos a crear un servicio de autoarranque en <a href="https://es.wikipedia.org/wiki/Systemd" class="btn btn--inverse btn--small" target="_blank">Systemd</a> con nuestro editor nano:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/systemd/system/vncserver@.service
</code></pre></div></div>
<p>Y agregamos el siguiente codigo:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">[</span>Unit]
<span class="nv">Description</span><span class="o">=</span>TightVNC Server
<span class="nv">After</span><span class="o">=</span>syslog.target network.target
<span class="o">[</span>Service]
<span class="nv">Type</span><span class="o">=</span>forking
<span class="nv">User</span><span class="o">=</span>pi
<span class="nv">Group</span><span class="o">=</span>pi
<span class="nv">WorkingDirectory</span><span class="o">=</span>/home/pi
<span class="nv">PIDFile</span><span class="o">=</span>/home/pi/.vnc/%H:%i.pid
<span class="nv">ExecStartPre</span><span class="o">=</span>-/usr/bin/vncserver <span class="nt">-kill</span> :%i <span class="o">></span> /dev/null 2>&1
<span class="nv">ExecStart</span><span class="o">=</span>/usr/bin/vncserver <span class="nt">-depth</span> 24 <span class="nt">-geometry</span> 1920x1080 :%i
<span class="nv">ExecStop</span><span class="o">=</span>/usr/bin/vncserver <span class="nt">-kill</span> :%i
<span class="o">[</span>Install]
<span class="nv">WantedBy</span><span class="o">=</span>multi-user.target
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y recargamos los servcios de <strong>Systemd</strong>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>systemctl daemon-reload
</code></pre></div></div>
<p>Ahora ya podemos habilitar el autoarranque de VNC tras reiniciar y habilitarlo en la sesión actual:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>systemctl <span class="nb">enable </span>vncserver@2.service <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>systemctl start vncserver@2.service
</code></pre></div></div>
<p>Si queremos comprobar como esta trabajando el servicio hacemos un check de status:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>systemctl status vncserver@2
</code></pre></div></div>
<p>En mi caso devuelve el siguiente código:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@overclock:~/.vnc<span class="nv">$ </span><span class="nb">sudo </span>systemctl status vncserver@2
● vncserver@2.service - TightVNC Server
Loaded: loaded <span class="o">(</span>/etc/systemd/system/vncserver@2.service<span class="p">;</span> enabled<span class="p">;</span> vendor preset: enabled<span class="o">)</span>
Active: active <span class="o">(</span>running<span class="o">)</span> since Sun 2019-04-14 16:21:22 CEST<span class="p">;</span> 1 day 1h ago
Main PID: 1386 <span class="o">(</span>Xtightvnc<span class="o">)</span>
CGroup: /system.slice/system-vncserver.slice/vncserver@2.service
├─ 1386 Xtightvnc :2 <span class="nt">-desktop</span> X <span class="nt">-auth</span> /home/pi/.Xauthority <span class="nt">-geometry</span> 1280x1024 <span class="nt">-depth</span> 24 <span class="nt">-rfbwait</span> 120000 <span class="nt">-rfb</span>
├─ 2005 /bin/sh /etc/X11/Xvnc-session
├─ 2007 x-session-manager
├─ 2031 dbus-launch <span class="nt">--autolaunch</span> 21d0957d47914be79fd212f1ac66978d <span class="nt">--binary-syntax</span> <span class="nt">--close-stderr</span>
├─ 2035 /usr/bin/dbus-daemon <span class="nt">--fork</span> <span class="nt">--print-pid</span> 5 <span class="nt">--print-address</span> 7 <span class="nt">--session</span>
├─ 2053 /usr/bin/dbus-launch <span class="nt">--exit-with-session</span> <span class="nt">--sh-syntax</span>
├─ 2058 /usr/bin/dbus-daemon <span class="nt">--fork</span> <span class="nt">--print-pid</span> 5 <span class="nt">--print-address</span> 7 <span class="nt">--session</span>
├─ 2075 /usr/bin/ssh-agent x-session-manager
├─ 2077 /usr/lib/at-spi2-core/at-spi-bus-launcher
├─ 2082 /usr/bin/dbus-daemon <span class="nt">--config-file</span><span class="o">=</span>/usr/share/defaults/at-spi2/accessibility.conf <span class="nt">--nofork</span> <span class="nt">--print-ad</span>
├─ 2084 /usr/lib/at-spi2-core/at-spi2-registryd <span class="nt">--use-gnome-session</span>
├─ 2089 /usr/lib/dconf/dconf-service
├─ 2095 gnome-keyring-daemon <span class="nt">--start</span>
├─ 2101 /usr/bin/mate-settings-daemon
├─ 2105 marco
├─ 2109 mate-panel
├─ 2111 /usr/lib/gvfs/gvfsd
├─ 2119 /usr/lib/gvfs/gvfsd-fuse /home/pi/.gvfs <span class="nt">-f</span> <span class="nt">-o</span> big_writes
├─ 2136 /usr/bin/pulseaudio <span class="nt">--start</span> <span class="nt">--log-target</span><span class="o">=</span>syslog
├─ 2166 mate-screensaver
├─ 2168 nm-applet
├─ 2171 mate-volume-control-applet
├─ 2200 /usr/lib/mate-panel/wnck-applet
</code></pre></div></div>
<p>A partir de ahora cuando queramos conectarnos vía VNC debemos recordar que sera la <code class="language-plaintext highlighter-rouge">IP de acceso y el puerto 5902</code> junto con la contraseña que le hubiesemos definido:</p>
<blockquote class="notice--info">
<p>vnc://192.168.1.90:5902</p>
</blockquote>
<h3 id="minidlna">MiniDLNA</h3>
<p><a href="https://lordpedal.github.io/gnu/linux/docker/debian-docker-ce/#docker-minidlna" class="btn btn--success btn--small" target="_blank">Ampliar información en esta entrada</a></p>
<h3 id="kodi">Kodi</h3>
<p><a href="https://kodi.tv/" target="_blank">Kodi</a> hace años que dejamos de conocerlo como XBMC (Xbox Media Center), pero incluso cuando llevaba aquel nombre ya se había convertido en uno de los <strong>centros multimedia más populares y completos</strong> que podíamos descargar en diferentes plataformas, y lo sigue siendo, solo que incluso mejor.</p>
<p><strong>Kodi es una aplicación gratuita y open source mantenida por voluntarios y donaciones</strong>. La versión oficial no incluye ningún tipo de contenido multimedia, solo las opciones para que gestiones el tuyo propio. Ese contenido puede provenir de tu disco, de una ubicación remota, un DVD, un Blu-ray, un servicio en la nube, etc.</p>
<p>Y podrías pensar, <strong>¿Porque instalar Kodi en el Servidor?</strong> La respuesta para mi es sencilla, <strong>un servidor en mi caso no deja de ser un PC</strong>, con el que puedo disfrutar de contenido multimedia.</p>
<p>Aprovechando los <strong>alías</strong> haremos uso de ellos para instalar <code class="language-plaintext highlighter-rouge">Kodi</code> con la siguiente sentencia:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>instalar kodi
</code></pre></div></div>
<p>Y listo, ya lo tendriamos instalado y funcional si estamos dentro del entorno gráfico en nuestro caso MATE, pero como nos gusta ir un paso más te habras dado cuenta que desde TTY no inicia debidamente.</p>
<p>La solución pasa por añadir un nuevo alías a nuestro base de datos, para ello lanzamos en la terminal:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>enlaces
</code></pre></div></div>
<p>Se nos abrira el fichero <code class="language-plaintext highlighter-rouge">/etc/bash.bashrc</code> con el editor <code class="language-plaintext highlighter-rouge">nano</code>. Añadimos el alías de Kodi al final del fichero:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">alias </span><span class="nv">kodi</span><span class="o">=</span><span class="s2">"/usr/bin/xinit /usr/bin/dbus-launch --exit-with-session /usr/bin/kodi-standalone -- :0 -nolisten tcp vt7"</span>
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y editamos las opciones de apagado en Kodi:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>nano /etc/polkit-1/localauthority/50-local.d/custom-actions.pkla
</code></pre></div></div>
<p>Y agregamos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">[</span>Actions <span class="k">for </span>kodi user]
<span class="nv">Identity</span><span class="o">=</span>unix-user:pi
<span class="nv">Action</span><span class="o">=</span>org.freedesktop.upower.<span class="k">*</span><span class="p">;</span>org.freedesktop.consolekit.system.<span class="k">*</span><span class="p">;</span>org.freedesktop.udisks.<span class="k">*</span><span class="p">;</span>org.freedesktop.login1.<span class="k">*</span>
<span class="nv">ResultAny</span><span class="o">=</span><span class="nb">yes
</span><span class="nv">ResultInactive</span><span class="o">=</span><span class="nb">yes
</span><span class="nv">ResultActive</span><span class="o">=</span><span class="nb">yes</span>
</code></pre></div></div>
<p>Guardamos los cambios, salimos del editor de texto y ya tendriamos Kodi disponible para lanzar desde la <strong>TTY</strong> sin fallos.</p>
<h3 id="yt-dlp">yt-dlp</h3>
<p><strong>yt-dlp</strong> es un programa escrito en python que nos facilita cierta gestión de contenido en las redes de streaming.</p>
<p>Para poder usarlo en nuestro sistema, primeramente debemos de actualizar los repositorios e instalar el paquete:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt-get update <span class="o">&&</span> <span class="nb">sudo </span>apt-get <span class="nt">-y</span> <span class="nb">install </span>yt-dlp
</code></pre></div></div>
<p>La versión incluida en la emisión de este tutorial es:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@overclock:<span class="nv">$ </span>yt-dlp <span class="nt">--version</span>
2023.03.04
</code></pre></div></div>
<blockquote>
<p>Y listo!</p>
</blockquote>LordpedalEn esta sección pretendo hablar de como optimizar y adaptar la distribución Debian Bookworm a un uso diario como Servidor doméstico, desde mi propia experiencia de usuario.Navidrome: Docker2022-05-22T12:00:00+02:002022-05-22T23:00:00+02:00https://lordpedal.github.io/gnu/linux/docker/navidrome-docker<p class="full"><img src="https://lordpedal.github.io/assets/images/Docker.png" alt="Docker" class="align-center" /></p>
<p><a href="https://www.navidrome.org/" class="btn btn--warning btn--small" target="_blank">Navidrome</a> es un servidor de música personal.</p>
<p>Gracias a este microservicio dispondremos de nuestra colección de música de forma sencilla y remota.</p>
<p>La dinámica de uso es muy sencilla, tan solo definimos la ruta donde alojamos los audios que queremos reproducir remotamente y listo.</p>
<p>Las principales características son:</p>
<ul>
<li>Consumo de recursos muy bajo, diseñado en lenguaje <code class="language-plaintext highlighter-rouge">Go</code>.</li>
<li>Compatible con cualquiera de los clientes desarrollados para Subsonic o Airsonic.</li>
<li>Capaz de gestionar grandes colecciones de música.</li>
<li>Reproduce practicamente cualquier formato de audio disponible.</li>
<li>Gestiona de forma genial la meta información de cada uno de los archivos.</li>
<li>Multi usuario.</li>
<li>Monitoriza de forma automática la librería en busca de cambios.</li>
<li>Sencillo pero eficaz reproductor web.</li>
<li>Soporta el transcodificado al vuelo.</li>
<li>Soporta listas y ademas te permite importar listas en formato m3u.</li>
</ul>
<h2 id="instalación">Instalación</h2>
<p>Vamos a realizar unos pasos previos para preparar el entorno, para ello en primer lugar creamos las carpetas donde alojar el proyecto:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">mkdir</span> <span class="nt">-p</span> <span class="nv">$HOME</span>/docker/navidrome/<span class="o">{</span>datos,musica<span class="o">}</span> <span class="o">&&</span> <span class="se">\</span>
<span class="nb">cd</span> <span class="nv">$HOME</span>/docker/navidrome
</code></pre></div></div>
<p>Ahora llega el turno de crear el fichero de configuración <code class="language-plaintext highlighter-rouge">docker-compose.yml</code> lanzando el siguiente comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cat</span> <span class="o"><<</span> <span class="no">EOF</span><span class="sh"> > </span><span class="nv">$HOME</span><span class="sh">/docker/navidrome/docker-compose.yml
version: '3'
services:
navidrome:
image: deluan/navidrome:latest
container_name: Navidrome
user: 1000:1000
ports:
- 4533:4533
environment:
ND_SCANSCHEDULE: "1h"
ND_LOGLEVEL: "info"
ND_SESSIONTIMEOUT: "24h"
ND_UIWELCOMEMESSAGE: "Another fine release by Lordpedal"
ND_DEFAULTTHEME: "Dark"
ND_ENABLECOVERANIMATION: "true"
ND_ENABLEDOWNLOADS: "true"
ND_DEVACTIVITYPANEL: "false"
volumes:
- './datos:/data'
- './musica:/music:ro'
restart: always
</span><span class="no">EOF
</span></code></pre></div></div>
<p>Vamos a repasar los principales parámetros que hemos añadido sobre la anterior base, para poder adaptarlos a nuestro sistema y configuración especifica:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">user: 1000:1000</code></td>
<td>Corresponde al PID y GID de nuestro usuario <code class="language-plaintext highlighter-rouge">id</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">4533:4533</code></td>
<td>Puerto de acceso <strong>interfaz Web</strong> <code class="language-plaintext highlighter-rouge">:4533</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">ND_SCANSCHEDULE: 1h</code></td>
<td>Definimos la frecuencia de <code class="language-plaintext highlighter-rouge">refresco base de datos</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">ND_LOGLEVEL: info</code></td>
<td>Nivel detalle <code class="language-plaintext highlighter-rouge">log</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">ND_SESSIONTIMEOUT: 24h</code></td>
<td>Tiempo que se mantendra la sesión abierta</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">ND_UIWELCOMEMESSAGE: Another fine release by Lordpedal</code></td>
<td>Mensaje de bienvenida</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">ND_DEFAULTTHEME: Dark</code></td>
<td>Tema <code class="language-plaintext highlighter-rouge">oscuro</code> por defecto</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">ND_ENABLECOVERANIMATION: true</code></td>
<td>Habilita animación de <code class="language-plaintext highlighter-rouge">portadas</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">ND_ENABLEDOWNLOADS: true</code></td>
<td>Habilita la opción de <code class="language-plaintext highlighter-rouge">descargas</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">ND_DEVACTIVITYPANEL: false</code></td>
<td>Desactiva el panel de desarrollo, reduce carga del servicio</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./datos:/data</code></td>
<td>Ruta donde almacena localmente la base datos</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./musica:/music:ro</code></td>
<td>Ruta donde almacenamos las canciones</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">restart: always</code></td>
<td>Habilitamos que tras reiniciar la maquina anfitrion vuelva a cargar el servicio</td>
</tr>
</tbody>
</table>
<p>Una vez configurado, levantamos el servicio para ser configurado y ejecutado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker-compose up <span class="nt">-d</span>
</code></pre></div></div>
<p>En mi caso, el servicio estaría disponible en la dirección web <a href="http://localhost:4533" class="btn btn--inverse btn--small" target="_blank">http://192.168.1.90:4533</a></p>
<p>Durante el primer acceso se nos solicitara la creación de un usuario con privilegios <code class="language-plaintext highlighter-rouge">admin</code>, posteriormente podremos añadir más usuarios.</p>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/navidrome.mp4" type="video/mp4" />
</video>
</div>
<p>Una vez finalizado el proceso de personalización nos puede quedar algo similar a este ejemplo:</p>
<figure>
<a href="/assets/images/posts/navi1.png"><img src="/assets/images/posts/navi1.png" /></a>
</figure>
<h2 id="nginx-proxy-manager">Nginx Proxy Manager</h2>
<p>Configuramos dominios y certificados que posteriormente usaremos para conectarnos en remoto:</p>
<figure>
<a href="/assets/images/posts/navidrome.png"><img src="/assets/images/posts/navidrome.png" /></a>
</figure>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm05.mp4" type="video/mp4" />
</video>
</div>
<h2 id="clientes-ios--android">Clientes: iOS / Android</h2>
<p>Existen varias aplicaciones compatibles con él pero recomiendo <code class="language-plaintext highlighter-rouge">substreamer</code> por su perfecta integración.</p>
<p>Tan solo definimos el dominio que usamos en remoto y el usuario para hacer login:</p>
<figure class="half">
<a href="/assets/images/posts/navi2.png"><img src="/assets/images/posts/navi2.png" /></a>
<a href="/assets/images/posts/navi3.png"><img src="/assets/images/posts/navi3.png" /></a>
</figure>
<blockquote>
<p>Y listo!</p>
</blockquote>LordpedalNavidrome es un servidor de música personal.Matrix Pushbits Addon: Docker2022-04-24T20:00:00+02:002022-04-28T23:00:00+02:00https://lordpedal.github.io/gnu/linux/docker/pushbits-docker<p class="full"><img src="https://lordpedal.github.io/assets/images/Docker.png" alt="Docker" class="align-center" /></p>
<p><a href="https://lordpedal.github.io/gnu/linux/docker/matrix-docker/" class="btn btn--warning btn--small" target="_blank">Matrix</a> vimos que es una red abierta para una comunicación segura y descentralizada.</p>
<p>Lo que vamos a realizar es la integración de <a href="https://github.com/pushbits" target="_blank"><strong>Pushbits</strong></a> mediante un docker sobre Matrix.</p>
<p><strong>Pushbits</strong> es un servidor de retransmisión para notificaciones push. Nos va a permitir enviar notificaciones a través de una <strong>API web</strong> simple y las entrega a través de la red <strong>Matrix</strong>.</p>
<p>El proyecto aún continúa en desarrollo pero tiene un enorme potencial, desarrollado en lenguaje <code class="language-plaintext highlighter-rouge">Go</code>.</p>
<p>Es ideal para incluir notificaciones en nuestros scripts y desarrollar posibles bots.</p>
<p>Hace un tiempo estuve usando un <a href="https://github.com/fabianonline/matrix.sh" target="_blank">script bash</a> a modo <em><code class="language-plaintext highlighter-rouge">bot</code></em> para integrar las notificaciones del sistema, pero no me convencía la flexibilidad de integración para servicios de <strong><code class="language-plaintext highlighter-rouge">Docker</code></strong> que como por ejemplo tiene <strong>Pushbits</strong>.</p>
<p>Como idea dejo las integraciones configuradas para la red <strong><code class="language-plaintext highlighter-rouge">Matrix</code></strong> en sustitución de <em><code class="language-plaintext highlighter-rouge">Telegram</code></em>:</p>
<ul>
<li>Notificaciones del <code class="language-plaintext highlighter-rouge">sistema</code></li>
<li>Notificaciones <code class="language-plaintext highlighter-rouge">Fail2ban</code></li>
<li>Descargas <code class="language-plaintext highlighter-rouge">.torrent</code></li>
<li>Eventos <code class="language-plaintext highlighter-rouge">Home Assistant</code></li>
<li><code class="language-plaintext highlighter-rouge">...</code></li>
</ul>
<h2 id="instalación">Instalación</h2>
<h3 id="requisitos-previos">Requisitos previos</h3>
<ul>
<li><a href="https://lordpedal.github.io/gnu/linux/docker/matrix-docker/" class="btn btn--info" target="_blank"><strong>Docker: Matrix</strong></a></li>
<li><a href="https://lordpedal.github.io/gnu/linux/docker/npm-docker/" class="btn btn--info" target="_blank"><strong>Docker: NPM</strong></a></li>
</ul>
<p class="notice--info">NOTA: Adicionalmente vamos a crear un usuario en nuestra red <strong>Matrix</strong> que usaremos de mediador informativo, en nuestro caso <strong>Morfeo</strong>.</p>
<h3 id="pushbits-addon-docker">Pushbits Addon: Docker</h3>
<p>Vamos a tomar la base de configuración del docker de Matrix para configurar el addon. En primer lugar creamos estructura adicional que usaremos para la creación del servicio:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">mkdir</span> <span class="nt">-p</span> <span class="nv">$HOME</span>/docker/matrix/datos
</code></pre></div></div>
<p>A continuación nos dirigimos a la ruta donde alojamos la configuración adicional:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> <span class="nv">$HOME</span>/docker/matrix/datos
</code></pre></div></div>
<p>Creamos el fichero de configuración genérico del servicio <em><code class="language-plaintext highlighter-rouge">(Actualizado 25/04/2022)</code></em>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>nano <span class="nv">$HOME</span>/docker/matrix/datos/config.yml
</code></pre></div></div>
<p>Y le añadimos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>debug: <span class="nb">false
</span>http:
<span class="c"># The address to listen on. If empty, listens on all available IP addresses of the system.</span>
listenaddress: <span class="s1">''</span>
<span class="c"># The port to listen on.</span>
port: 8080
database:
<span class="c"># Currently sqlite3 and mysql are supported.</span>
dialect: <span class="s1">'sqlite3'</span>
<span class="c"># For sqlite3, specifies the database file. For mysql, specifies the connection string. Check out</span>
<span class="c"># https://github.com/go-sql-driver/mysql#dsn-data-source-name for details.</span>
connection: <span class="s1">'pushbits.db'</span>
admin:
<span class="c"># The username of the initial admin.</span>
name: <span class="s1">'admin'</span>
<span class="c"># The password of the initial admin.</span>
password: <span class="s1">'admin'</span>
<span class="c"># The Matrix ID of the initial admin, where notifications for that admin are sent to.</span>
<span class="c"># [required]</span>
matrixid: <span class="s1">''</span>
matrix:
<span class="c"># The Matrix server to use for sending notifications.</span>
homeserver: <span class="s1">'https://matrix.org'</span>
<span class="c"># The username of the Matrix account to send notifications from.</span>
<span class="c"># [required]</span>
username: <span class="s1">''</span>
<span class="c"># The password of the Matrix account to send notifications from.</span>
<span class="c"># [required]</span>
password: <span class="s1">''</span>
security:
<span class="c"># Wether or not to check for weak passwords using HIBP.</span>
checkhibp: <span class="nb">false
</span>crypto:
<span class="c"># Configuration of the KDF for password storage. Do not change unless you know what you are doing!</span>
argon2:
memory: 131072
iterations: 4
parallelism: 4
saltlength: 16
keylength: 32
formatting:
<span class="c"># Whether to use colored titles based on the message priority (<0: grey, 0-3: default, 4-10: yellow, 10-20: orange, >20: red).</span>
coloredtitle: <span class="nb">false
</span>alertmanager:
<span class="c"># The name of the entry in the alerts annotations or lables that should be used for the title</span>
annotationtitle: title
<span class="c"># The name of the entry in the alerts annotations or labels that should be used for the message</span>
annotationmessage: message
</code></pre></div></div>
<p>Y creamos el fichero de base de datos con permisos de nuestro usuario de sistema:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">touch</span> <span class="nv">$HOME</span>/docker/matrix/datos/pushbits.db
</code></pre></div></div>
<p>Volvemos al directorio raíz de nuestro docker y hacemos un backup del fichero de configuración:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> <span class="nv">$HOME</span>/docker/matrix <span class="o">&&</span> <span class="se">\</span>
<span class="nb">cp </span>docker-compose.yml docker-compose.old
</code></pre></div></div>
<p>Definimos un upgrade del mismo con las nuevas variables:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cat</span> <span class="o"><<</span> <span class="no">EOF</span><span class="sh"> >> </span><span class="nv">$HOME</span><span class="sh">/docker/matrix/docker-compose.yml
pushbits:
image: ghcr.io/pushbits/server:latest
container_name: Pushbits
ports:
- '8080:8080'
environment:
PUSHBITS_DATABASE_DIALECT: 'sqlite3'
PUSHBITS_HTTP_PORT: '8080'
PUSHBITS_ADMIN_NAME: 'Empalador'
PUSHBITS_ADMIN_PASSWORD: 'Nocturno'
PUSHBITS_MATRIX_HOMESERVER: 'https://minipc.lordpedal.duckdns.org'
PUSHBITS_ADMIN_MATRIXID: '@lordpedal:minipc.lordpedal.duckdns.org'
PUSHBITS_MATRIX_USERNAME: 'morfeo'
PUSHBITS_MATRIX_PASSWORD: 'GrOundHOG'
volumes:
- '/etc/localtime:/etc/localtime:ro'
- '/etc/timezone:/etc/timezone:ro'
- './datos:/data'
restart: always
</span><span class="no">EOF
</span></code></pre></div></div>
<p>Vamos a repasar los principales parámetros que hemos añadido sobre la anterior base, para poder adaptarlos a nuestro sistema y configuración especifica:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">8080:8080</code></td>
<td>Puerto de notificaciones <strong>Push</strong> <code class="language-plaintext highlighter-rouge">:8080</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">PUSHBITS_DATABASE_DIALECT: sqlite3</code></td>
<td>Definimos tipo base datos a usar, <code class="language-plaintext highlighter-rouge">./datos/config.yml</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">PUSHBITS_HTTP_PORT: 8080</code></td>
<td>Definimos puerto notificaciones a usar, <code class="language-plaintext highlighter-rouge">./datos/config.yml</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">PUSHBITS_ADMIN_NAME: Empalador</code></td>
<td>Creamos usuario admin Pushbits, <code class="language-plaintext highlighter-rouge">./datos/config.yml</code> <strong>Recomiendo cambiar</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">PUSHBITS_ADMIN_PASSWORD: Nocturno</code></td>
<td>Contraseña usuario admin Pushbits, <code class="language-plaintext highlighter-rouge">./datos/config.yml</code> <strong>Recomiendo cambiar</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">PUSHBITS_MATRIX_HOMESERVER: https://minipc.lordpedal.duckdns.org</code></td>
<td>Dirección de nuestro servidor Matrix a usar, <strong>Necesario sustituir</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">PUSHBITS_ADMIN_MATRIXID: @lordpedal:minipc.lordpedal.duckdns.org</code></td>
<td>Usuario de nuestro servidor que va a recibir notificaciones, <strong>Necesario sustituir</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">PUSHBITS_MATRIX_USERNAME: morfeo</code></td>
<td>Usuario adicional que creamos en los requisitos previos para enviar notificaciones, <strong>Necesario sustituir</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">PUSHBITS_MATRIX_PASSWORD: GrOundHOG</code></td>
<td>Contraseña usuario adicional para enviar notificaciones, <strong>Necesario sustituir</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">/etc/localtime:/etc/localtime:ro</code></td>
<td>Clona hora del sistema anfitrión <code class="language-plaintext highlighter-rouge">(solo lectura)</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">/etc/timezone:/etc/timezone:ro</code></td>
<td>Clona zona horaria del sistema anfitrión <code class="language-plaintext highlighter-rouge">(solo lectura)</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./datos: data</code></td>
<td>Ruta donde almacena la base datos y consultas</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">restart: always</code></td>
<td>Habilitamos que tras reiniciar la maquina anfitrion vuelva a cargar el servicio</td>
</tr>
</tbody>
</table>
<p>Una vez configurado, levantamos nuevamente el servicio para ser reconfigurado y ejecutado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker-compose up <span class="nt">-d</span>
</code></pre></div></div>
<p>En mi caso, el servicio estaría disponible en la siguiente dirección <a href="http://localhost:8080/health" class="btn btn--inverse btn--small" target="_blank">http://192.168.1.90:8080/health</a></p>
<h3 id="nginx-proxy-manager">Nginx Proxy Manager</h3>
<p>Configuramos dominios y certificados:</p>
<figure>
<a href="/assets/images/posts/pushbits.png"><img src="/assets/images/posts/pushbits.png" /></a>
</figure>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm05.mp4" type="video/mp4" />
</video>
</div>
<h3 id="pushbits-addon-cli">Pushbits Addon: CLI</h3>
<p>Para poder usar el servicio de notificaciones necesitamos de dos requisitos en Matrix:</p>
<ul>
<li>Una <code class="language-plaintext highlighter-rouge">SALA</code> de comunicación</li>
<li>Un <code class="language-plaintext highlighter-rouge">TOKEN</code> de dicha sala para poder interactuar con el servicio</li>
</ul>
<p>Para obtener ambos parámetros usaremos una aplicación de terminal adicional. En el momento de escribir esta entrada la release <a href="https://github.com/pushbits/cli" target="_blank"><strong>v0.0.3</strong></a> es la que usaremos.</p>
<p>Nos volvemos a dirigr a la ruta donde alojamos la configuración del proyecto:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> <span class="nv">$HOME</span>/docker/matrix/datos
</code></pre></div></div>
<p>Descargamos y descomprimimos el paquete compilado elegido, en nuestro caso usaremos arquitectura PC 64bits:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>wget https://github.com/pushbits/cli/releases/download/v0.0.3/cli_0.0.3_linux_amd64.tar.gz <span class="o">&&</span> <span class="se">\</span>
<span class="nb">tar</span> <span class="nt">-xf</span> <span class="s1">'cli_0.0.3_linux_amd64.tar.gz'</span>
</code></pre></div></div>
<p>Damos permisos de ejecución al fichero de configuración:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">chmod</span> +x cli
</code></pre></div></div>
<p>Procedemos a crear la sala y obtener el token con los datos que hemos ido creando en el proyecto:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>./cli application create Matrix <span class="nt">--url</span> https://pushbits.lordpedal.duckdns.org <span class="nt">--username</span> Empalador
</code></pre></div></div>
<p>Vamos a repasar el comando para poder adaptarlo a nuestro sistema sin problemas:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">./cli application create Matrix</code></td>
<td>Creamos la <strong>Sala</strong> <code class="language-plaintext highlighter-rouge">Matrix</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">--url https://pushbits.lordpedal.duckdns.org</code></td>
<td>Dirección del servicio <code class="language-plaintext highlighter-rouge">Pushbits</code> creado en <strong>NPM</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">--username Empalador</code></td>
<td>Usuario admin de Pushbits que definimos en <code class="language-plaintext highlighter-rouge">docker-compose.yml</code></td>
</tr>
</tbody>
</table>
<p>Adjunto ejemplo de la ejecución completa del comando previo:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@overclock:~/docker/matrix/datos<span class="nv">$ </span>./cli application create Matrix <span class="nt">--url</span> https://pushbits.lordpedal.duckdns.org <span class="nt">--username</span> Empalador
Current password of user Empalador: Nocturno
<span class="o">{</span>
<span class="s2">"id"</span>: 1,
<span class="s2">"name"</span>: <span class="s2">"Matrix"</span>,
<span class="s2">"token"</span>: <span class="s2">"Z3JvdW5kaG9kIGRheQ=="</span>
<span class="o">}</span>
</code></pre></div></div>
<p class="notice--info">NOTA: Anotamos el <code class="language-plaintext highlighter-rouge">token</code> para uso posterior en nuestros scripts.</p>
<p>Tras ejecutarlo en nuestra aplicación de mensajeria Matrix veremos como el usuario <strong><code class="language-plaintext highlighter-rouge">@lordpedal:minipc.lordpedal.duckdns.org</code></strong> que definimos en <code class="language-plaintext highlighter-rouge">docker-compose.yml</code> para ser notificados, recibira una invitación a la sala <strong>Matrix</strong> recien creada.</p>
<h2 id="notificación">Notificación</h2>
<p>Vamos a enviar un comando de prueba para comprobar que todo esta debidamente configurado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>curl <span class="se">\</span>
<span class="nt">--header</span> <span class="s2">"Content-Type: application/json"</span> <span class="se">\</span>
<span class="nt">--request</span> POST <span class="se">\</span>
<span class="nt">--data</span> <span class="s1">'{"message":"La IP del dispositivo es '</span><span class="si">$(</span><span class="nb">hostname</span> <span class="nt">-I</span> | <span class="nb">awk</span> <span class="s1">'{print $1}'</span><span class="si">)</span><span class="s1">'","title":"Overclock Server"}'</span> <span class="se">\</span>
<span class="s2">"https://pushbits.lordpedal.duckdns.org/message?token=Z3JvdW5kaG9kIGRheQ=="</span>
</code></pre></div></div>
<p class="notice--warning">NOTA: Sustituye el valor <code class="language-plaintext highlighter-rouge">https://pushbits.lordpedal.duckdns.org/message?token=Z3JvdW5kaG9kIGRheQ==</code> por tu servidor y el token del mismo.</p>
<figure>
<a href="/assets/images/posts/pushbits2.png"><img src="/assets/images/posts/pushbits2.png" /></a>
</figure>
<blockquote>
<p>Y listo!</p>
</blockquote>LordpedalMatrix vimos que es una red abierta para una comunicación segura y descentralizada.NPM GoAccess Addon: Docker2022-04-21T10:45:00+02:002022-04-28T23:00:00+02:00https://lordpedal.github.io/gnu/linux/docker/npmgo-docker<p class="full"><img src="https://lordpedal.github.io/assets/images/Docker.png" alt="Docker" class="align-center" /></p>
<p><a href="https://lordpedal.github.io/gnu/linux/docker/npm-docker/" class="btn btn--warning btn--small" target="_blank">NPM</a> vimos que es un proxy inverso y sobre dicha base vamos a trabajar esta entrada.</p>
<p>Lo que vamos a realizar es la integración de <a href="https://github.com/xavier-hernandez/goaccess-for-nginxproxymanager" target="_blank"><strong>GoAccess</strong></a> mediante un docker sobre NPM, para poder consultar de forma detallada los logs de nuestros microservicios.</p>
<p>Los logs que consulta son los que siguen el siguiente patrón:</p>
<ul>
<li><strong>proxy-host-*_access.log.gz</strong></li>
<li><strong>proxy-host-*_access.log</strong></li>
<li><strong>proxy-host-*.log</strong></li>
</ul>
<p>Y gracias a ellos tendremos información muy útil de forma visual desde el <strong>estado de consultas, número de visitantes, origen de visitantes, navegador usado, IP’s, sistemas operativos, …</strong></p>
<h2 id="instalación">Instalación</h2>
<h3 id="npm">NPM</h3>
<p><a href="https://lordpedal.github.io/gnu/linux/docker/npm-docker/" class="btn btn--warning" target="_blank">Requisito obligatorio tener instalado <strong>Docker: NPM</strong></a></p>
<h3 id="goaccess-addon">GoAccess Addon</h3>
<p>Vamos a tomar la base de configuración del docker de NPM para configurar el addon. En primer nos dirigimos a la ruta donde alojamos el proyecto:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> <span class="nv">$HOME</span>/docker/npm
</code></pre></div></div>
<p>Hacemos un backup del fichero de configuración:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cp </span>docker-compose.yml docker-compose.old
</code></pre></div></div>
<p>Definimos un upgrade del mismo con las nuevas variables:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cat</span> <span class="o"><<</span> <span class="no">EOF</span><span class="sh"> >> </span><span class="nv">$HOME</span><span class="sh">/docker/npm/docker-compose.yml
goaccess:
image: xavierh/goaccess-for-nginxproxymanager:latest
container_name: GoACCESS_NPM
volumes:
- './datos/logs/:/opt/log/:ro'
ports:
- '82:7880'
environment:
- PUID=0
- PGID=0
- TZ=Europe/Madrid
- SKIP_ARCHIVED_LOGS=False
- BASIC_AUTH=True
- BASIC_AUTH_USERNAME=Empalador
- BASIC_AUTH_PASSWORD=Nocturno
restart: always
</span><span class="no">EOF
</span></code></pre></div></div>
<p class="notice--info">NOTA: Si quieres montar el servicio en una arquitectura <strong>ARM</strong> sustituye la variable <strong>xavierh/goaccess-for-nginxproxymanager:latest</strong> por <strong>justsky/goaccess-for-nginxproxymanager:latest</strong></p>
<p>Vamos a repasar los principales parámetros que hemos añadido sobre la anterior base, para poder adaptarlos a nuestro sistema y configuración especifica:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">./datos/logs/:/opt/log/:ro</code></td>
<td>Ruta donde NPM almacena los logs y <strong>consulta en modo lectura</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">82:7880</code></td>
<td>Puerto de gestión <strong>Web</strong> <code class="language-plaintext highlighter-rouge">:82</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">PUID=0</code></td>
<td>Habilitamos persmisos de <strong>root</strong> para consultar logs</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">PGID=0</code></td>
<td>Habilitamos persmisos de <strong>root</strong> para consultar logs</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">TZ=Europe/Madrid</code></td>
<td>Zona horaria <code class="language-plaintext highlighter-rouge">Europa/Madrid</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">SKIP_ARCHIVED_LOGS=False</code></td>
<td>Habilitamos consultar <strong>todos los logs, incluso los comprimidos</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">BASIC_AUTH=True</code></td>
<td>Habilitamos acceso con usuario y contraseña al servicio</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">BASIC_AUTH_USERNAME=Empalador</code></td>
<td>Usuario creado para acceso, <strong>recomiendo cambiarlo</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">BASIC_AUTH_PASSWORD=Nocturno</code></td>
<td>Contraseña creada para acceso, <strong>recomiendo cambiarla</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">restart: always</code></td>
<td>Habilitamos que tras reiniciar la maquina anfitrion vuelva a cargar el servicio</td>
</tr>
</tbody>
</table>
<p>Una vez configurado, levantamos nuevamente el servicio para ser reconfigurado y ejecutado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker-compose up <span class="nt">-d</span>
</code></pre></div></div>
<p>Si consultamos el estado del docker, veremos que los logs han sido cargados:</p>
<figure>
<a href="/assets/images/posts/goaccess.png"><img src="/assets/images/posts/goaccess.png" /></a>
</figure>
<p>En mi caso, el servicio estaría disponible en la dirección web <a href="http://localhost:82" class="btn btn--inverse btn--small" target="_blank">http://192.168.1.90:82</a></p>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/goaccess.mp4" type="video/mp4" />
</video>
</div>
<h2 id="nginx-proxy-manager">Nginx Proxy Manager</h2>
<p>Configuramos dominios y certificados:</p>
<figure>
<a href="/assets/images/posts/goaccess2.png"><img src="/assets/images/posts/goaccess2.png" /></a>
</figure>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm05.mp4" type="video/mp4" />
</video>
</div>
<blockquote>
<p>Y listo!</p>
</blockquote>LordpedalNPM vimos que es un proxy inverso y sobre dicha base vamos a trabajar esta entrada.VanDAM 3D: Docker2022-04-19T16:00:00+02:002023-11-05T22:00:00+01:00https://lordpedal.github.io/gnu/linux/docker/vandam-docker<p class="full"><img src="https://lordpedal.github.io/assets/images/Docker.png" alt="Docker" class="align-center" /></p>
<p><a href="https://github.com/Floppy/van_dam" class="btn btn--warning btn--small" target="_blank">VanDAM</a> es un gestor de contenido digital, diseñado específicamente para archivos de impresión 3D.</p>
<p>Es una alternativa local y autogestionada a macroservicios online como <a href="https://www.thingiverse.com/" target="_blank">Thingiverse</a>, <a href="https://cults3d.com/" target="_blank">Cults3D</a>, …</p>
<p>La dinámica de uso es muy sencilla, tan solo definimos una biblioteca, alojamos los ficheros que hayamos diseñado o bien queramos tener gestionados y listo.</p>
<p>Es proyecto aún en fase de desarrollo y tiene cierto margen de mejora en la gestión, pero realmente merece la pena darle una oportunidad de uso.</p>
<h2 id="instalación">Instalación</h2>
<p>Vamos a realizar unos pasos previos para preparar el entorno, para ello en primer lugar creamos las carpetas donde alojar el proyecto:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">mkdir</span> <span class="nt">-p</span> <span class="nv">$HOME</span>/docker/vandam/<span class="o">{</span>stl,bdatos<span class="o">}</span> <span class="o">&&</span> <span class="se">\</span>
<span class="nb">cd</span> <span class="nv">$HOME</span>/docker/vandam
</code></pre></div></div>
<p>Agregamos el paquete <code class="language-plaintext highlighter-rouge">openssl</code> para generar una clave de cifrado para la base de datos:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo </span>apt-get update <span class="o">&&</span> <span class="se">\</span>
<span class="nb">sudo </span>apt-get <span class="nt">-y</span> <span class="nb">install </span>openssl
</code></pre></div></div>
<p>Generamos la clave de forma aleatoria y la anotamos para usarla en la creación del <strong>docker</strong>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>openssl rand <span class="nt">-base64</span> 32
</code></pre></div></div>
<p>Como ejemplo muestro un resultado de la ejecución del comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>pi@overclock:~<span class="nv">$ </span>openssl rand <span class="nt">-base64</span> 32
gED04yiDeyItG6e9GO/OPCd+IBFZOoAIFkM6/3ZllcI<span class="o">=</span>
</code></pre></div></div>
<p>Ahora llega el turno de crear el fichero de configuración <code class="language-plaintext highlighter-rouge">docker-compose.yml</code> lanzando el siguiente comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cat</span> <span class="o"><<</span> <span class="no">EOF</span><span class="sh"> > </span><span class="nv">$HOME</span><span class="sh">/docker/vandam/docker-compose.yml
version: "3"
services:
app:
image: ghcr.io/floppy/van_dam:latest
container_name: VanDAM
ports:
- 8993:3214
volumes:
- ./stl:/Diseños
environment:
DATABASE_URL: postgresql://van_dam:overclockserver@db/van_dam?pool=5
SECRET_KEY_BASE: gED04yiDeyItG6e9GO/OPCd+IBFZOoAIFkM6/3ZllcI=
REDIS_URL: redis://redis:6379/1
restart: always
depends_on:
- db
- redis
networks:
- vandam
links:
- db
- redis
db:
image: postgres:15
container_name: VanDAM_DB
volumes:
- ./bdatos:/var/lib/postgresql/data
environment:
POSTGRES_USER: van_dam
POSTGRES_PASSWORD: overclockserver
restart: always
networks:
- vandam
redis:
image: redis:7
container_name: VanDAM_REDIS
restart: always
networks:
- vandam
volumes:
db_data:
networks:
vandam:
</span><span class="no">EOF
</span></code></pre></div></div>
<p>Vamos a repasar los principales parámetros que hemos añadido sobre la anterior base, para poder adaptarlos a nuestro sistema y configuración especifica:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">8993:3214</code></td>
<td>Puerto de acceso <strong>interfaz Web</strong> <code class="language-plaintext highlighter-rouge">:8993</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./stl:/Diseños</code></td>
<td>Ruta donde alojamos nuestros ficheros 3D <code class="language-plaintext highlighter-rouge">$HOME/docker/vandam/stl</code> y la ruta de la biblioteca que nos solicitara al iniciarse <code class="language-plaintext highlighter-rouge">/Diseños</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">SECRET_KEY_BASE: gED04yiDeyItG6e9GO/OPCd+IBFZOoAIFkM6/3ZllcI=</code></td>
<td>Clave de cifrado base datos, <strong>recomiendo cambiarla por la propia generada</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./bdatos:/var/lib/postgresql/data</code></td>
<td>Ruta donde almacena localmente la base datos</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">restart: always</code></td>
<td>Habilitamos que tras reiniciar la maquina anfitrion vuelva a cargar el servicio</td>
</tr>
</tbody>
</table>
<p>Una vez configurado, levantamos el servicio para ser configurado y ejecutado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker-compose up <span class="nt">-d</span>
</code></pre></div></div>
<p>En mi caso, el servicio estaría disponible en la dirección web <a href="http://localhost:8993" class="btn btn--inverse btn--small" target="_blank">http://192.168.1.90:8993</a></p>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/vandam.mp4" type="video/mp4" />
</video>
</div>
<h2 id="nginx-proxy-manager">Nginx Proxy Manager</h2>
<p>Configuramos dominios y certificados:</p>
<figure>
<a href="/assets/images/posts/vandam.png"><img src="/assets/images/posts/vandam.png" /></a>
</figure>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm05.mp4" type="video/mp4" />
</video>
</div>
<blockquote>
<p>Y listo!</p>
</blockquote>LordpedalVanDAM es un gestor de contenido digital, diseñado específicamente para archivos de impresión 3D.draw.io: Docker2022-04-18T15:00:00+02:002022-04-28T23:00:00+02:00https://lordpedal.github.io/gnu/linux/docker/drawio-docker<p class="full"><img src="https://lordpedal.github.io/assets/images/Docker.png" alt="Docker" class="align-center" /></p>
<p><a href="https://drawio-app.com/" class="btn btn--warning btn--small" target="_blank">draw.io</a> es una herramienta de creación y edición de diagramas libre que permite la integración con diversas plataformas.</p>
<p>Es una herramienta que en principio puede estar pensada para uso profesional, pero realmente se puede usar si se tiene un nivel de destrezas mínimas. Simple, sencilla e intuitiva. Sus principales ventajas son:</p>
<ul>
<li><strong>Integración</strong>: se puede utilizar en versión online o de escritorio. En versiones online se puede vincular a diferentes cuentas y guardar los trabajos en sistemas de almacenamiento en la nube.</li>
<li><strong>Plantillas y librerías</strong>: tanto para profes como para alumnos los inicios a veces son duros, por lo que la herramienta dispone de una serie de plantillas organizadas por tipos que hacen el trabajo más sencillo y más rápido.</li>
<li><strong>Sencillez de uso</strong>: la interfaz de Draw.io es sencilla, cuenta con las herramientas básicas para poder desarrollar la experiencia, lo que facilita la utilización.</li>
<li><strong>Compartir y cooperar</strong>: Creando archivos que pueden ser editados por varias personas al mismo tiempo y que permite publicar o compartir cualquier archivo a través de un link.</li>
</ul>
<p>En esta entrada vamos a centrarnos en crear un servidor propio de diseño como siempre de forma sencilla.</p>
<h2 id="instalación">Instalación</h2>
<p>Vamos a realizar unos pasos previos para preparar el entorno, para ello en primer lugar creamos las carpetas donde alojar el proyecto:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">mkdir</span> <span class="nt">-p</span> <span class="nv">$HOME</span>/docker/drawio <span class="o">&&</span> <span class="se">\</span>
<span class="nb">cd</span> <span class="nv">$HOME</span>/docker/drawio
</code></pre></div></div>
<p>Ahora llega el turno de crear el fichero de configuración <code class="language-plaintext highlighter-rouge">docker-compose.yml</code> lanzando el siguiente comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cat</span> <span class="o"><<</span> <span class="no">EOF</span><span class="sh"> > </span><span class="nv">$HOME</span><span class="sh">/docker/drawio/docker-compose.yml
version: '3'
services:
drawio:
image: jgraph/drawio:latest
container_name: DrawIO
ports:
- 8992:8080
restart: always
healthcheck:
test: ["CMD-SHELL", "curl -f http://localhost:8080 || exit 1"]
interval: 1m30s
timeout: 10s
retries: 5
start_period: 10s
</span><span class="no">EOF
</span></code></pre></div></div>
<p>Vamos a repasar los principales parámetros que hemos añadido sobre la anterior base, para poder adaptarlos a nuestro sistema y configuración especifica:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">8992:8080</code></td>
<td>Puerto de acceso <strong>interfaz Web</strong> <code class="language-plaintext highlighter-rouge">:8992</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">restart: always</code></td>
<td>Habilitamos que tras reiniciar la maquina anfitrion vuelva a cargar el servicio</td>
</tr>
</tbody>
</table>
<p>Una vez configurado, levantamos el servicio para ser configurado y ejecutado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker-compose up <span class="nt">-d</span>
</code></pre></div></div>
<p>En mi caso, el servicio estaría disponible en la dirección web <a href="http://localhost:8992" class="btn btn--inverse btn--small" target="_blank">http://192.168.1.90:8992</a></p>
<h3 id="guías">Guías</h3>
<p>En la web oficial se incluyen unas <a href="https://drawio-app.com/tutorials/" class="btn btn--info btn--small" target="_blank">guías de aprendizaje</a> bastante sencillas que recomiendo revisar.</p>
<h2 id="nginx-proxy-manager">Nginx Proxy Manager</h2>
<p>Configuramos dominios y certificados:</p>
<figure>
<a href="/assets/images/posts/drawio.png"><img src="/assets/images/posts/drawio.png" /></a>
</figure>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm05.mp4" type="video/mp4" />
</video>
</div>
<blockquote>
<p>Y listo!</p>
</blockquote>Lordpedaldraw.io es una herramienta de creación y edición de diagramas libre que permite la integración con diversas plataformas.NPM Fail2Ban Addon: Docker2022-04-15T18:30:00+02:002022-04-28T23:00:00+02:00https://lordpedal.github.io/gnu/linux/docker/npmf2b-docker<p class="full"><img src="https://lordpedal.github.io/assets/images/Docker.png" alt="Docker" class="align-center" /></p>
<p><a href="https://lordpedal.github.io/gnu/linux/docker/npm-docker/" class="btn btn--warning btn--small" target="_blank">NPM</a> vimos que es un proxy inverso y sobre dicha base vamos a trabajar esta entrada.</p>
<p>Lo que vamos a realizar es la integración de <a href="https://lordpedal.github.io/gnu/linux/debian-11-servidor/#fail2ban" target="_blank"><strong>Fail2ban</strong></a> mediante un docker sobre NPM, para poder bloquear usos abusivos de nuestros microservicios.</p>
<h2 id="instalación">Instalación</h2>
<h3 id="id-telegram--token-bot">ID Telegram + Token BOT</h3>
<p><a href="https://lordpedal.github.io/gnu/linux/debian-11-servidor/#lordpedal-bot" class="btn btn--info" target="_blank">Requisito obligatorio tener datos notificación <strong>Telegram</strong></a></p>
<h3 id="npm">NPM</h3>
<p><a href="https://lordpedal.github.io/gnu/linux/docker/npm-docker/" class="btn btn--warning" target="_blank">Requisito obligatorio tener instalado <strong>Docker: NPM</strong></a></p>
<h3 id="fail2ban-addon">Fail2ban Addon</h3>
<p>Vamos a tomar la base de configuración del docker de NPM para configurar el addon. En primer nos dirigimos a la ruta donde alojamos el proyecto:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> <span class="nv">$HOME</span>/docker/npm
</code></pre></div></div>
<p>Hacemos un backup del fichero de configuración:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cp </span>docker-compose.yml docker-compose.old
</code></pre></div></div>
<p>Creamos las carpetas adicionales del proyecto:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">mkdir</span> <span class="nt">-p</span> <span class="nv">$HOME</span>/docker/npm/fail2ban/<span class="o">{</span>action.d,db,filter.d,jail.d<span class="o">}</span>
</code></pre></div></div>
<h4 id="acción-fail2ban">Acción Fail2ban</h4>
<p>Creamos el fichero acción de configuración:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>nano <span class="nv">$HOME</span>/docker/npm/fail2ban/action.d/telegram.conf
</code></pre></div></div>
<p>Y le añadimos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># Fail2Ban configuration file</span>
<span class="c">#</span>
<span class="c"># Author: Lordpedal</span>
<span class="c">#</span>
<span class="o">[</span>Definition]
<span class="c"># Option: actionstart</span>
<span class="c"># Notes.: command executed once at the start of Fail2Ban.</span>
<span class="c"># Values: CMD</span>
<span class="c">#</span>
actionstart <span class="o">=</span> /data/action.d/fail2ban-telegram.sh start
<span class="c"># Option: actionstop</span>
<span class="c"># Notes.: command executed once at the end of Fail2Ban</span>
<span class="c"># Values: CMD</span>
<span class="c">#</span>
actionstop <span class="o">=</span> /data/action.d/fail2ban-telegram.sh stop
<span class="c"># Option: actioncheck</span>
<span class="c"># Notes.: command executed once before each actionban command</span>
<span class="c"># Values: CMD</span>
<span class="c">#</span>
actioncheck <span class="o">=</span>
<span class="c"># Option: actionban</span>
<span class="c"># Notes.: command executed when banning an IP. Take care that the</span>
<span class="c"># command is executed with Fail2Ban user rights.</span>
<span class="c"># Tags: See jail.conf(5) man page</span>
<span class="c"># Values: CMD</span>
<span class="c">#</span>
actionban <span class="o">=</span> /data/action.d/fail2ban-telegram.sh ban <ip>
<span class="c"># Option: actionunban</span>
<span class="c"># Notes.: command executed when unbanning an IP. Take care that the</span>
<span class="c"># command is executed with Fail2Ban user rights.</span>
<span class="c"># Tags: See jail.conf(5) man page</span>
<span class="c"># Values: CMD</span>
<span class="c">#</span>
actionunban <span class="o">=</span> /data/action.d/fail2ban-telegram.sh unban <ip>
<span class="o">[</span>Init]
name <span class="o">=</span> npm-docker
init <span class="o">=</span> 21121981
</code></pre></div></div>
<p>Creamos el script de notificación:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>nano <span class="nv">$HOME</span>/docker/npm/fail2ban/action.d/fail2ban-telegram.sh
</code></pre></div></div>
<p>Y le añadimos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#!/bin/bash</span>
<span class="c">#</span>
<span class="c"># https://lordpedal.github.io</span>
<span class="c"># Another fine release by Lordpedal</span>
<span class="c">#</span>
<span class="k">while </span><span class="nb">true
</span><span class="k">do
if </span>ping <span class="nt">-c</span> 1 <span class="nt">-W</span> 3 google.com 1>/dev/null 2>&1
<span class="k">then
</span><span class="nb">echo</span> <span class="s2">""</span>
<span class="nb">break
</span><span class="k">else
</span><span class="nb">echo</span> <span class="s2">""</span>
<span class="k">fi
</span><span class="nb">sleep </span>1
<span class="k">done</span>
<span class="c"># Opciones ejecucion</span>
<span class="nv">info</span><span class="o">=</span><span class="sb">`</span><span class="nb">hostname</span> <span class="nt">-f</span><span class="sb">`</span>
<span class="k">function </span>show_uso <span class="o">{</span>
<span class="nb">echo</span> <span class="s2">"NPM2ban Telegram by Lordpedal"</span>
<span class="nb">echo</span> <span class="s2">""</span>
<span class="nb">echo</span> <span class="s2">"Usar: </span><span class="nv">$0</span><span class="s2"> opcion <ip>"</span>
<span class="nb">echo</span> <span class="s2">""</span>
<span class="nb">echo</span> <span class="s2">"Opcion: start (Inicia notificaciones)"</span>
<span class="nb">echo</span> <span class="s2">" stop (Detiene notificaciones)"</span>
<span class="nb">echo</span> <span class="s2">" ban <ip> (Banea IP especificada) Ej: ban 192.168.1.2"</span>
<span class="nb">echo</span> <span class="s2">" unban <ip> (Desbanea IP especificada) Ej: unban 192.168.1.2"</span>
<span class="nb">echo</span> <span class="s2">""</span>
<span class="nb">exit</span>
<span class="o">}</span>
<span class="c"># Notificacion</span>
<span class="k">function </span>send_msg <span class="o">{</span>
<span class="c"># ID Telegram</span>
<span class="nv">telegram</span><span class="o">=</span>79593223
<span class="c"># Enlace BOT (Cambiar Token 289352425:AAHBCcKicDtSFaY2_Gq1brnXJ5CaGba6tMA)</span>
<span class="nv">url</span><span class="o">=</span><span class="s2">"https://api.telegram.org/bot289352425:AAHBCcKicDtSFaY2_Gq1brnXJ5CaGba6tMA/sendMessage"</span>
<span class="c"># Envia mensaje</span>
curl <span class="nt">-s</span> <span class="nt">-X</span> POST <span class="nv">$url</span> <span class="nt">-d</span> <span class="nv">chat_id</span><span class="o">=</span><span class="nv">$telegram</span> <span class="nt">-d</span> <span class="nv">text</span><span class="o">=</span><span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span>
<span class="nb">exit</span>
<span class="o">}</span>
<span class="c"># Chequea argumentos de script</span>
<span class="k">if</span> <span class="o">[</span> <span class="nv">$# </span><span class="nt">-lt</span> 1 <span class="o">]</span>
<span class="k">then
</span>show_uso
<span class="k">fi</span>
<span class="c"># Ejecuta una accion depende del argumento</span>
<span class="k">if</span> <span class="o">[</span> <span class="nv">$# </span><span class="nt">-lt</span> 1 <span class="o">]</span>
<span class="k">then
</span>show_uso
<span class="k">fi</span>
<span class="c"># Ejecuta una accion depende del argumento</span>
<span class="k">if</span> <span class="o">[</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span> <span class="o">=</span> <span class="s1">'start'</span> <span class="o">]</span>
<span class="k">then
</span><span class="nv">msg</span><span class="o">=</span><span class="s2">"Seguridad+NPM2ban+ha+sido+iniciada+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span>
send_msg <span class="nv">$msg</span>
<span class="k">elif</span> <span class="o">[</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span> <span class="o">=</span> <span class="s1">'stop'</span> <span class="o">]</span>
<span class="k">then
</span><span class="nv">msg</span><span class="o">=</span><span class="s2">"Seguridad+NPM2ban+ha+sido+detenida+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span>
send_msg <span class="nv">$msg</span>
<span class="k">elif</span> <span class="o">[</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span> <span class="o">=</span> <span class="s1">'ban'</span> <span class="o">]</span>
<span class="k">then
</span><span class="nv">msg</span><span class="o">=</span><span class="si">$(</span><span class="o">[</span> <span class="s2">"</span><span class="nv">$2</span><span class="s2">"</span> <span class="o">!=</span> <span class="s1">''</span> <span class="o">]</span> <span class="o">&&</span> <span class="nb">echo</span> <span class="s2">"Seguridad+NPM2ban+ha+baneado+a+</span><span class="nv">$2</span><span class="s2">+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span> <span class="o">||</span> <span class="nb">echo</span> <span class="s2">"Seguridad+NPM2ban+ha+baneado+una+ip+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span> <span class="si">)</span>
send_msg <span class="nv">$msg</span>
<span class="k">elif</span> <span class="o">[</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span> <span class="o">=</span> <span class="s1">'unban'</span> <span class="o">]</span>
<span class="k">then
</span><span class="nv">msg</span><span class="o">=</span><span class="si">$(</span><span class="o">[</span> <span class="s2">"</span><span class="nv">$2</span><span class="s2">"</span> <span class="o">!=</span> <span class="s1">''</span> <span class="o">]</span> <span class="o">&&</span> <span class="nb">echo</span> <span class="s2">"Seguridad+NPM2ban+ha+desbaneado+a+</span><span class="nv">$2</span><span class="s2">+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span> <span class="o">||</span> <span class="nb">echo</span> <span class="s2">"Seguridad+NPM2ban+ha+desbaneado+una+ip+en+el+host+</span><span class="nv">$info</span><span class="s2">"</span> <span class="si">)</span>
send_msg <span class="nv">$msg</span>
<span class="k">else
</span>show_uso
<span class="k">fi</span>
</code></pre></div></div>
<p class="notice--info">Recuerda que debes de cambiar los parametros del ID Telegram + Token BOT</p>
<p>Y le otorgamos permisos de ejecución:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">chmod</span> +x <span class="nv">$HOME</span>/docker/npm/fail2ban/action.d/fail2ban-telegram.sh
</code></pre></div></div>
<h4 id="filtro-fail2ban">Filtro Fail2ban</h4>
<p>Definimos el filtro de consulta en los logs para que se ejecute la protección:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>nano <span class="nv">$HOME</span>/docker/npm/fail2ban/filter.d/npm-docker.conf
</code></pre></div></div>
<p>Y le añadimos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">[</span>INCLUDES]
<span class="o">[</span>Definition]
failregex <span class="o">=</span> ^<HOST>.+<span class="s2">" (4</span><span class="se">\d\d</span><span class="s2">|3</span><span class="se">\d\d</span><span class="s2">) (</span><span class="se">\d\d\d</span><span class="s2">|</span><span class="se">\d</span><span class="s2">) .+</span><span class="err">$</span><span class="s2">
^.+ 4</span><span class="se">\d\d</span><span class="s2"> </span><span class="se">\d\d\d</span><span class="s2"> - .+ </span><span class="se">\[</span><span class="s2">Client <HOST></span><span class="se">\]</span><span class="s2"> </span><span class="se">\[</span><span class="s2">Length .+</span><span class="se">\]</span><span class="s2"> "</span>.+<span class="s2">" .+</span><span class="err">$</span><span class="s2">
ignoreregex =
</span></code></pre></div></div>
<h4 id="reglas-fail2ban">Reglas Fail2ban</h4>
<p>Para que Fail2ban nos proteja tenemos que definir unas variables de sistema, en dichas variables por ejemplo le decimos que no bloquee consultas de nuestra red local, el nº máximo de intentos, el tiempo de baneo, …</p>
<p>Para ello creamos la siguiente regla:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>nano <span class="nv">$HOME</span>/docker/npm/fail2ban/jail.d/npm-docker.local
</code></pre></div></div>
<p>Y le añadimos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">[</span>npm-docker]
enabled <span class="o">=</span> <span class="nb">true
</span>ignoreip <span class="o">=</span> 127.0.0.1/8 192.168.1.0/24
action <span class="o">=</span> telegram
chain <span class="o">=</span> INPUT
port <span class="o">=</span> http,https
logpath <span class="o">=</span> /log/npm/default-host_access.log
/log/npm/proxy-host-<span class="k">*</span>_access.log
/log/npm/proxy-host-<span class="k">*</span>_error.log
maxretry <span class="o">=</span> 3
bantime <span class="o">=</span> 3600
findtime <span class="o">=</span> 86400
</code></pre></div></div>
<p class="notice--info">Recuerda que en caso de usar una red en otro rango diferente a 192.168.1.0/24 cambiarla. Como por ejemplo 192.168.0.0/24</p>
<h4 id="upgrade-docker-compose">Upgrade docker-compose</h4>
<p>Definimos un upgrade del mismo con las nuevas variables:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cat</span> <span class="o"><<</span> <span class="no">EOF</span><span class="sh"> >> </span><span class="nv">$HOME</span><span class="sh">/docker/npm/docker-compose.yml
fail2ban:
image: crazymax/fail2ban:latest
container_name: NPM2BAN
network_mode: "host"
cap_add:
- NET_ADMIN
- NET_RAW
volumes:
- './fail2ban:/data'
- '/var/log/auth.log:/var/log/auth.log:ro'
- './datos/logs/:/log/npm/:ro'
environment:
TZ: 'Europe/Madrid'
F2B_LOG_TARGET: 'STDOUT'
F2B_LOG_LEVEL: 'INFO'
F2B_DB_PURGE_AGE: '1d'
restart: always
</span><span class="no">EOF
</span></code></pre></div></div>
<p>Vamos a repasar los principales parámetros que hemos añadido sobre la anterior base, para poder adaptarlos a nuestro sistema y configuración especifica:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">network_mode: host</code></td>
<td>Habilitamos el uso de acceo a la red no virtualizada</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">NET_ADMIN</code></td>
<td>Habilitamos permisos de administrador</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">NET_RAW</code></td>
<td>Habilitamos persmisos de administrador de red</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">TZ: Europe/Madrid</code></td>
<td>Zona horaria <code class="language-plaintext highlighter-rouge">Europa/Madrid</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">F2B_LOG_TARGET: STDOUT</code></td>
<td>Destino de consulta log</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">F2B_LOG_LEVEL: INFO</code></td>
<td>Nivel de información log</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">F2B_DB_PURGE_AGE: 1d</code></td>
<td>Limpieza baneos base datos</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">restart: always</code></td>
<td>Habilitamos que tras reiniciar la maquina anfitrion vuelva a cargar el servicio</td>
</tr>
</tbody>
</table>
<p>Una vez configurado, levantamos nuevamente el servicio para ser reconfigurado y ejecutado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker-compose up <span class="nt">-d</span>
</code></pre></div></div>
<figure>
<a href="/assets/images/posts/npmf2b.jpg"><img src="/assets/images/posts/npmf2b.jpg" /></a>
</figure>
<blockquote>
<p>Y listo!</p>
</blockquote>LordpedalNPM vimos que es un proxy inverso y sobre dicha base vamos a trabajar esta entrada.WTF!2022-02-19T00:45:00+01:002022-02-19T08:30:00+01:00https://lordpedal.github.io/personal/60h-cita<blockquote>
<p><strong>Puedes pedirme cualquier cosa que quieras, excepto tiempo.</strong></p>
</blockquote>
<blockquote>
<p><cite><a href="https://es.wikipedia.org/wiki/Napole%C3%B3n_Bonaparte" target="_blank">Napoleón</a></cite></p>
</blockquote>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/60h.mp4" type="video/mp4" />
</video>
</div>LordpedalPuedes pedirme cualquier cosa que quieras, excepto tiempo.Matrix: Docker2022-02-16T21:00:00+01:002023-09-17T23:00:00+02:00https://lordpedal.github.io/gnu/linux/docker/matrix-docker<p class="full"><img src="https://lordpedal.github.io/assets/images/Docker.png" alt="Docker" class="align-center" /></p>
<p><a href="https://matrix.org/" class="btn btn--warning btn--small" target="_blank">Matrix</a> una red abierta para una comunicación segura y descentralizada.</p>
<p>Sencillo y contundente eslogan, para presentar un estándar de código abierto en ofrecer sistemas de comunicación descentralizados, cifrados y en tiempo real.</p>
<p>En Matrix, cada mensaje enviado pasa por el servidor local de cada uno de los participantes en la conversación.</p>
<p>Sus creadores afirman que esta es la mejor forma de democratizar el control de los usuarios sobre sus comunicaciones, sin que haya un único punto de control por el que pasen los mensajes.</p>
<p>En esta entrada vamos a centrarnos en crear un servidor propio de comunicación con acceso a la red federada de forma sencilla.</p>
<h2 id="instalación">Instalación</h2>
<p>Vamos a realizar unos pasos previos para preparar el entorno, para ello en primer lugar creamos las carpetas donde alojar el proyecto:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">mkdir</span> <span class="nt">-p</span> <span class="nv">$HOME</span>/docker/matrix/riot <span class="o">&&</span> <span class="se">\</span>
<span class="nb">cd</span> <span class="nv">$HOME</span>/docker/matrix
</code></pre></div></div>
<p class="notice--info">Importante aclarar que antes de continuar, que debemos de elegir un nombre dominio para su alojamiento, en mi caso he seleccionado <strong>minipc.lordpedal.duckdns.org</strong> y el tutorial se basa en él. <strong>Importante</strong> comentar que el proyecto genera claves de cifrado en base a él.</p>
<h3 id="configuración-servidor">Configuración Servidor</h3>
<p>Comenzamos creando los ficheros de configuración del servicio, para ello usaremos la siguiente plantilla:</p>
<p class="notice--info">NOTA: Si quieres montar el servicio en una arquitectura <strong>ARM</strong> sustituye la variable <strong>matrixdotorg/synapse:latest</strong> por <strong>black0/synapse:latest</strong></p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker run <span class="nt">-it</span> <span class="nt">--rm</span> <span class="se">\</span>
<span class="nt">-v</span> <span class="nv">$HOME</span>/docker/matrix/config:/data <span class="se">\</span>
<span class="nt">--name</span><span class="o">=</span>Matrix <span class="se">\</span>
<span class="nt">-e</span> <span class="nv">SYNAPSE_SERVER_NAME</span><span class="o">=</span>minipc.lordpedal.duckdns.org <span class="se">\</span>
<span class="nt">-e</span> <span class="nv">SYNAPSE_REPORT_STATS</span><span class="o">=</span>no <span class="se">\</span>
<span class="nt">-e</span> <span class="nv">UID</span><span class="o">=</span>1000 <span class="se">\</span>
<span class="nt">-e</span> <span class="nv">GID</span><span class="o">=</span>1000 <span class="se">\</span>
matrixdotorg/synapse:latest generate
</code></pre></div></div>
<p>Vamos a repasar los principales parámetros que hemos añadido sobre la anterior base, para poder adaptarlos a nuestro sistema y configuración especifica:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">$HOME/docker/matrix/config:/data</code></td>
<td>Ruta donde aloja la <strong>configuración</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">SYNAPSE_SERVER_NAME=minipc.lordpedal.duckdns.org</code></td>
<td>Dominio elegido para publicar el proyecto, <strong>IMPORTANTE SUSTITUIR</strong> ya que las claves de cifrado se basan en él</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">SYNAPSE_REPORT_STATS=no</code></td>
<td>Desactivamos el reporte <strong>anonimo de estadísticas</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">UID=1000</code></td>
<td>UID de nuestro usuario. Para saber nuestro ID ejecutar en terminal: <code class="language-plaintext highlighter-rouge">id</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">GID=1000</code></td>
<td>GID de nuestro usuario. Para saber nuestro ID ejecutar en terminal: <code class="language-plaintext highlighter-rouge">id</code></td>
</tr>
</tbody>
</table>
<p>Ahora llega el turno de cambiar los permisos de estructura, en mi caso a usuario sistema <strong>pi</strong>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">sudo chown </span>pi:pi <span class="nt">-R</span> <span class="nv">$HOME</span>/docker/matrix <span class="o">&&</span> <span class="se">\</span>
<span class="nb">cd</span> <span class="nv">$HOME</span>/docker/matrix/config
</code></pre></div></div>
<p>Entramos en la carpeta de configuración del servicio y editamos los parámetros para nuestro servidor:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> <span class="nv">$HOME</span>/docker/matrix/config <span class="o">&&</span> <span class="se">\</span>
nano homeserver.yaml
</code></pre></div></div>
<p>Empezamos buscando el apartado del cliente que posteriormente configuraremos en el fichero <code class="language-plaintext highlighter-rouge">docker-compose.yml</code>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#web_client_location: https://riot.example.com/</span>
</code></pre></div></div>
<p>Descomentamos la linea y especificamos un dominio de nuestro <strong>DuckDNS</strong>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>web_client_location: https://element.lordpedal.duckdns.org/
</code></pre></div></div>
<p>Activamos el acceso a la red federada mediante <strong>HTTPS</strong>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#serve_server_wellknown: true</span>
</code></pre></div></div>
<p>Para ello descomentamos la opción:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>serve_server_wellknown: <span class="nb">true</span>
</code></pre></div></div>
<p>Activamos la política del periodo retención de canales:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>retention:
<span class="c">#enabled: true</span>
</code></pre></div></div>
<p>Para ello descomentamos la opción:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>retention:
enabled: <span class="nb">true</span>
</code></pre></div></div>
<p>Cambiamos la base datos por defecto <strong>SQLite3</strong> a <strong>PostgreSQL</strong> que posteriormente activaremos en <code class="language-plaintext highlighter-rouge">docker-compose.yml</code>:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>database:
name: sqlite3
args:
database: /data/homeserver.db
</code></pre></div></div>
<p>Comentamos la configuración por defecto y añadimos las siguientes variables:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#database:</span>
<span class="c"># name: sqlite3</span>
<span class="c"># args:</span>
<span class="c"># database: /data/homeserver.db</span>
database:
name: psycopg2
args:
user: synapse
password: Matrix2kLordpedal
database: synapse
host: postgresql
cp_min: 5
cp_max: 10
</code></pre></div></div>
<p>Activamos la opción de registrar usuarios en nuestro servidor:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#enable_registration: false</span>
</code></pre></div></div>
<p>Descomentamos la opción y cambiamos la orden:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>enable_registration: <span class="nb">true
</span>enable_registration_without_verification: <span class="nb">true</span>
</code></pre></div></div>
<p>Activamos la opción de cuentas de invitado para consultar canales públicos:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#allow_guest_access: false</span>
</code></pre></div></div>
<p>Descomentamos la opción y cambiamos la orden:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>allow_guest_access: <span class="nb">true</span>
</code></pre></div></div>
<p>Activamos la opción suprimir mensajes de advertencia en el servidor de autentificación de matrix.org</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c">#suppress_key_server_warning: true</span>
</code></pre></div></div>
<p>Descomentamos la opción y cambiamos la orden:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>suppress_key_server_warning: <span class="nb">true</span>
</code></pre></div></div>
<p>Activamos la opción de optimización de base datos <strong>Redis</strong></p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>redis:
<span class="c">#enabled: true</span>
<span class="c">#host: localhost</span>
<span class="c">#port: 6379</span>
</code></pre></div></div>
<p>Descomentando y configurandolo de la siguiente forma:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>redis:
enabled: <span class="nb">true
</span>host: redis
port: 6379
</code></pre></div></div>
<p>Guardamos el fichero con la combinación <strong>CTRL + O</strong> y salimos del editor <strong>CTRL + X</strong></p>
<h3 id="configuración-cliente">Configuración Cliente</h3>
<p>Toca el turno de configurar el cliente web que añadiremos a nuestro servidor, lanzando el siguiente comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>nano <span class="nv">$HOME</span>/docker/matrix/riot/config.json
</code></pre></div></div>
<p>Y le añadimos el siguiente contenido:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">{</span>
<span class="s2">"default_server_config"</span>: <span class="o">{</span>
<span class="s2">"m.homeserver"</span>: <span class="o">{</span>
<span class="s2">"base_url"</span>: <span class="s2">"https://minipc.lordpedal.duckdns.org"</span>,
<span class="s2">"server_name"</span>: <span class="s2">"minipc.lordpedal.duckdns.org"</span>
<span class="o">}</span>,
<span class="s2">"m.identity_server"</span>: <span class="o">{</span>
<span class="s2">"base_url"</span>: <span class="s2">"https://vector.im"</span>
<span class="o">}</span>
<span class="o">}</span>,
<span class="s2">"disable_custom_urls"</span>: <span class="nb">false</span>,
<span class="s2">"disable_guests"</span>: <span class="nb">false</span>,
<span class="s2">"disable_login_language_selector"</span>: <span class="nb">false</span>,
<span class="s2">"disable_3pid_login"</span>: <span class="nb">false</span>,
<span class="s2">"brand"</span>: <span class="s2">"Element"</span>,
<span class="s2">"integrations_ui_url"</span>: <span class="s2">"https://scalar.vector.im/"</span>,
<span class="s2">"integrations_rest_url"</span>: <span class="s2">"https://scalar.vector.im/api"</span>,
<span class="s2">"integrations_widgets_urls"</span>: <span class="o">[</span>
<span class="s2">"https://scalar.vector.im/_matrix/integrations/v1"</span>,
<span class="s2">"https://scalar.vector.im/api"</span>,
<span class="s2">"https://scalar-staging.vector.im/_matrix/integrations/v1"</span>,
<span class="s2">"https://scalar-staging.vector.im/api"</span>,
<span class="s2">"https://scalar-staging.riot.im/scalar/api"</span>
<span class="o">]</span>,
<span class="s2">"bug_report_endpoint_url"</span>: <span class="s2">"https://riot.im/bugreports/submit"</span>,
<span class="s2">"defaultCountryCode"</span>: <span class="s2">"ES"</span>,
<span class="s2">"showLabsSettings"</span>: <span class="nb">false</span>,
<span class="s2">"features"</span>: <span class="o">{</span>
<span class="s2">"feature_new_spinner"</span>: <span class="s2">"labs"</span>,
<span class="s2">"feature_pinning"</span>: <span class="s2">"labs"</span>,
<span class="s2">"feature_custom_status"</span>: <span class="s2">"labs"</span>,
<span class="s2">"feature_custom_tags"</span>: <span class="s2">"labs"</span>,
<span class="s2">"feature_state_counters"</span>: <span class="s2">"labs"</span>
<span class="o">}</span>,
<span class="s2">"default_federate"</span>: <span class="nb">true</span>,
<span class="s2">"default_theme"</span>: <span class="s2">"ligth"</span>,
<span class="s2">"roomDirectory"</span>: <span class="o">{</span>
<span class="s2">"servers"</span>: <span class="o">[</span>
<span class="s2">"matrix.org"</span>,
<span class="s2">"gitter.im"</span>,
<span class="s2">"libera.chat"</span>
<span class="o">]</span>
<span class="o">}</span>,
<span class="s2">"welcomeUserId"</span>: <span class="s2">"@riot-bot:matrix.org"</span>,
<span class="s2">"piwik"</span>: <span class="o">{</span>
<span class="s2">"url"</span>: <span class="s2">"https://piwik.riot.im/"</span>,
<span class="s2">"whitelistedHSUrls"</span>: <span class="o">[</span>
<span class="s2">"https://matrix.org"</span>
<span class="o">]</span>,
<span class="s2">"whitelistedISUrls"</span>: <span class="o">[</span>
<span class="s2">"https://vector.im"</span>,
<span class="s2">"https://matrix.org"</span>
<span class="o">]</span>,
<span class="s2">"siteId"</span>: 1
<span class="o">}</span>,
<span class="s2">"enable_presence_by_hs_url"</span>: <span class="o">{</span>
<span class="s2">"https://matrix.org"</span>: <span class="nb">false</span>,
<span class="s2">"https://matrix-client.matrix.org"</span>: <span class="nb">false</span>
<span class="o">}</span>,
<span class="s2">"settingDefaults"</span>: <span class="o">{</span>
<span class="s2">"breadcrumbs"</span>: <span class="nb">true</span>
<span class="o">}</span>,
<span class="s2">"jitsi"</span>: <span class="o">{</span>
<span class="s2">"preferredDomain"</span>: <span class="s2">"jitsi.riot.im"</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p>Vamos a repasar los principales parámetros que hemos añadido sobre la anterior base, para poder adaptarlos a nuestro sistema y configuración especifica:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">base_url: https://minipc.lordpedal.duckdns.org</code></td>
<td>Ruta acceso servidor <strong>IMPORTANTE CAMBIAR</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">server_name: https://minipc.lordpedal.duckdns.org</code></td>
<td>Servidor Matrix <strong>IMPORTANTE CAMBIAR</strong></td>
</tr>
</tbody>
</table>
<h3 id="configuración-docker-compose">Configuración docker-compose</h3>
<p>Ahora llega el turno de crear el fichero de configuración <code class="language-plaintext highlighter-rouge">docker-compose.yml</code> lanzando el siguiente comando:</p>
<p class="notice--info">NOTA: Si quieres montar el servicio en una arquitectura <strong>ARM</strong> sustituye la variable <strong>matrixdotorg/synapse:latest</strong> por <strong>black0/synapse:latest</strong></p>
<p class="notice--warning">EXTRA: Debido a incompatibilidad con la BD Postgres 16 se debe de cambiar la versión de <strong>latest</strong> a <strong>15</strong> <em>(Septiembre 2023)</em></p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cat</span> <span class="o"><<</span> <span class="no">EOF</span><span class="sh"> > </span><span class="nv">$HOME</span><span class="sh">/docker/matrix/docker-compose.yml
version: '2'
services:
redis:
image: "redis:latest"
container_name: Redis_Matrix
restart: always
matrix:
image: "docker.io/matrixdotorg/synapse:latest"
container_name: Matrix
ports:
- 8008:8008
- 8448:8448
volumes:
- "./config:/data"
environment:
- TZ=Europe/Madrid
- UID=1000
- GID=1000
- SYNAPSE_SERVER_NAME=minipc.lordpedal.duckdns.org
- SYNAPSE_REPORT_STATS=no
restart: always
postgresql:
#image: "postgres:latest"
image: "postgres:15"
container_name: Matrix_DB
environment:
POSTGRES_DB: "synapse"
POSTGRES_PASSWORD: "Matrix2kLordpedal"
POSTGRES_USER: "synapse"
POSTGRES_INITDB_ARGS: "--encoding='UTF8' --lc-collate='C' --lc-ctype='C'"
volumes:
- "./bdatos:/var/lib/postgresql/data"
restart: always
riot:
image: "vectorim/element-web:latest"
container_name: Matrix_Rio
ports:
- 8009:80
volumes:
- "./riot/config.json:/app/config.json:ro"
restart: always
</span><span class="no">EOF
</span></code></pre></div></div>
<p>Vamos a repasar los principales parámetros que hemos añadido sobre la anterior base, para poder adaptarlos a nuestro sistema y configuración especifica:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">8008:8008</code></td>
<td>Puerto de comunicación público <strong>SERVIDOR</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">8448:8448</code></td>
<td>Puerto de comunicación <strong>Red Federada</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./config:/data</code></td>
<td>Ruta donde aloja la configuración del <strong>SERVIDOR</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">TZ=Europe/Madrid</code></td>
<td>Zona horaria <code class="language-plaintext highlighter-rouge">Europa/Madrid</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">UID=1000</code></td>
<td>UID de nuestro usuario. Para saber nuestro ID ejecutar en terminal: <code class="language-plaintext highlighter-rouge">id</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">GID=1000</code></td>
<td>GID de nuestro usuario. Para saber nuestro ID ejecutar en terminal: <code class="language-plaintext highlighter-rouge">id</code></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">SYNAPSE_SERVER_NAME=minipc.lordpedal.duckdns.org</code></td>
<td>Dominio elegido para publicar el proyecto, <strong>IMPORTANTE SUSTITUIR</strong> ya que las claves de cifrado se basan en él</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">SYNAPSE_REPORT_STATS=no</code></td>
<td>Desactivamos el reporte <strong>anonimo de estadísticas</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">Parametros POSTGRES</code></td>
<td>Usuario, contraseña, ruta y puerto comunicación <strong>Base de datos</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./bdatos:/var/lib/postgresql/data</code></td>
<td>Ruta donde aloja la <strong>Base de datos</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">8009:80</code></td>
<td>Puerto de comunicación público <strong>CLIENTE</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./riot/config.json:/app/config.json:ro</code></td>
<td>Ruta donde almacena la configuración del <strong>CLIENTE</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">restart: always</code></td>
<td>Habilitamos que tras reiniciar la maquina anfitrion vuelva a cargar el servicio</td>
</tr>
</tbody>
</table>
<p>Una vez configurado, levantamos el servicio para ser configurado y ejecutado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker-compose up <span class="nt">-d</span>
</code></pre></div></div>
<p>En mi caso, el servicio estaría disponible en la dirección web <a href="http://localhost:8008/_matrix/static/" class="btn btn--inverse btn--small" target="_blank">http://192.168.1.90:8008/_matrix/static/</a></p>
<figure>
<a href="/assets/images/posts/matrix01.png"><img src="/assets/images/posts/matrix01.png" /></a>
</figure>
<h3 id="nginx-proxy-manager">Nginx Proxy Manager</h3>
<p>Configuramos dominios y certificados:</p>
<figure class="half">
<a href="/assets/images/posts/matrix02.png"><img src="/assets/images/posts/matrix02.png" /></a>
<a href="/assets/images/posts/matrix03.png"><img src="/assets/images/posts/matrix03.png" /></a>
</figure>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm05.mp4" type="video/mp4" />
</video>
</div>
<h3 id="red-federada">Red Federada</h3>
<p>Debemos de comprobar que el sistema esta debidamente configurado y con acceso a la red global con el siguiente test:</p>
<p><a href="https://federationtester.matrix.org/" class="btn btn--info btn--large" target="_blank">Matrix Federation Tester</a></p>
<figure>
<a href="/assets/images/posts/matrix04.png"><img src="/assets/images/posts/matrix04.png" /></a>
</figure>
<h3 id="cuentas-usuario">Cuentas usuario</h3>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/matrix.mp4" type="video/mp4" />
</video>
</div>
<h4 id="desactivar-registro-cuentas">Desactivar registro cuentas</h4>
<p>Una vez creadas las cuentas de usuario que necesitemos, recomiendo volver a desactivar la opción de registro de cuentas.</p>
<p>Para ello volvemos a editar el fichero de configuración del servidor:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> <span class="nv">$HOME</span>/docker/matrix/config <span class="o">&&</span> <span class="se">\</span>
nano homeserver.yaml
</code></pre></div></div>
<p>Buscamos las variable que previamente habiamos activado para el registro:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>enable_registration: <span class="nb">true
</span>enable_registration_without_verification: <span class="nb">true
</span>suppress_key_server_warning: <span class="nb">true</span>
</code></pre></div></div>
<p>Y la desactivamos:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>enable_registration: <span class="nb">false
</span>enable_registration_without_verification: <span class="nb">false
</span>suppress_key_server_warning: <span class="nb">false</span>
</code></pre></div></div>
<p>Guardamos el fichero con la combinación <strong>CTRL + O</strong>, salimos del editor <strong>CTRL + X</strong> y reiniciamos el servicio con las nuevas variables:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cd</span> <span class="nv">$HOME</span>/docker/matrix <span class="o">&&</span> <span class="se">\</span>
docker-compose restart
</code></pre></div></div>
<blockquote>
<p>Y listo!</p>
</blockquote>LordpedalMatrix una red abierta para una comunicación segura y descentralizada.Nginx Proxy Manager: Docker2022-02-12T22:00:00+01:002023-03-17T16:30:00+01:00https://lordpedal.github.io/gnu/linux/docker/npm-docker<p class="full"><img src="https://lordpedal.github.io/assets/images/Docker.png" alt="Docker" class="align-center" /></p>
<p><a href="https://nginxproxymanager.com/" class="btn btn--warning btn--small" target="_blank">Nginx Proxy Manager</a> en adelante <strong>NPM</strong>, es un <em>Proxy inverso</em> con el cual podremos redirigir las solicitudes a las distintas aplicaciones del sistema a un servicio web.</p>
<p>Integra una sencilla gestión sobre los certificados <strong>SSL</strong>, usando por ejemplo <strong>Let’s Encrypt</strong> como autoridad certificadora para acceso <em>https</em> y con renovación de forma automatizada de los mismos.</p>
<p>Es una alternativa a <a href="https://lordpedal.github.io/docker/traefikv1-docker/" class="btn btn--info btn--small" target="_blank">Traefik</a> y como ambos usan los mismos puertos de comunicación externos no son compatibles en el mismo sistema.</p>
<p>Como proxy inverso <strong>no tendremos que abrir los puertos específicos de nuestros contenedores Docker en la NAT de nuestro Router</strong>, sino que seran accesibles a traves de los <strong>puertos 80 (HTTP) y 443 (HTTPS)</strong> que si deberemos de abrirlos antes de continuar (específicamente TCP, no UDP)</p>
<h2 id="instalación">Instalación</h2>
<p>Vamos a realizar unos pasos previos para preparar el entorno. En primer lugar creamos las carpetas donde alojar el proyecto:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">mkdir</span> <span class="nt">-p</span> <span class="nv">$HOME</span>/docker/npm <span class="o">&&</span> <span class="se">\</span>
<span class="nb">cd</span> <span class="nv">$HOME</span>/docker/npm
</code></pre></div></div>
<p>Ahora vamos a crear el fichero de configuración <code class="language-plaintext highlighter-rouge">docker-compose.yml</code> lanzando el siguiente comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nb">cat</span> <span class="o"><<</span> <span class="no">EOF</span><span class="sh"> > </span><span class="nv">$HOME</span><span class="sh">/docker/npm/docker-compose.yml
version: '3'
services:
app:
image: 'jc21/nginx-proxy-manager:latest'
container_name: NginxProxy
ports:
- '80:80'
- '81:81'
- '443:443'
environment:
DB_MYSQL_HOST: "db"
DB_MYSQL_PORT: 3306
DB_MYSQL_USER: "npm"
DB_MYSQL_PASSWORD: "npm"
DB_MYSQL_NAME: "npm"
volumes:
- ./datos:/data
- ./certificados:/etc/letsencrypt
restart: always
db:
image: 'jc21/mariadb-aria:latest'
container_name: MariaDB_NPM
environment:
MYSQL_ROOT_PASSWORD: 'npm'
MYSQL_DATABASE: 'npm'
MYSQL_USER: 'npm'
MYSQL_PASSWORD: 'npm'
volumes:
- ./bdatos:/var/lib/mysql
restart: always
</span><span class="no">EOF
</span></code></pre></div></div>
<p class="notice--info">Si queremos instalar NPM en una RPi o equipo con procesador ARM, tendremos que cambiar el docker de Base de Datos <code class="language-plaintext highlighter-rouge">jc21/mariadb-aria:latest</code> por <code class="language-plaintext highlighter-rouge">yobasystems/alpine-mariadb:latest</code></p>
<p>Vamos a repasar los principales parámetros que hemos añadido sobre la anterior base, para poder adaptarlos a nuestro sistema y configuración especifica:</p>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">80:80</code></td>
<td>Puerto de comunicación público</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">81:81</code></td>
<td>Puerto de acceso <strong>interfaz Web configuración</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">443:443</code></td>
<td>Puerto de comunicación público con certificados <strong>SSL</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">Parametros MYSQL</code></td>
<td>Usuario, contraseña, ruta y puerto comunicación <strong>Base de datos</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./datos:/data</code></td>
<td>Ruta donde almacena la <strong>configuración</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./certificados:/etc/letsencrypt</code></td>
<td>Ruta donde almacena los <strong>certificados SSL</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">./bdatos:/var/lib/mysql</code></td>
<td>Ruta donde almacena la <strong>Base de datos</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">restart: always</code></td>
<td>Habilitamos que tras reiniciar la maquina anfitrion vuelva a cargar el servicio</td>
</tr>
</tbody>
</table>
<p>Una vez configurado, levantamos el servicio para ser configurado y ejecutado:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker-compose up <span class="nt">-d</span>
</code></pre></div></div>
<h2 id="configuración">Configuración</h2>
<p>En mi caso, el servicio estaría disponible en la dirección web <a href="http://localhost:81" class="btn btn--inverse btn--small" target="_blank">http://192.168.1.90:81</a></p>
<p class="notice--info">NOTA: El usuario por defecto para el primer acceso es <strong>admin@example.com</strong> y la contraseña <strong>changeme</strong></p>
<h3 id="general">General</h3>
<p>Durante el primer inicio de sesión se nos solicitara la configuración del usuario:</p>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm01.mp4" type="video/mp4" />
</video>
</div>
<p>Otro aspecto interesante a configurar es la redirección a otro dominio en caso de introducir un dominio inexistente:</p>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm02.mp4" type="video/mp4" />
</video>
</div>
<h3 id="certificados">Certificados</h3>
<p>Vamos a generar un certicado comodín para todos nuestros microservicios y de esa forma no tener que generar certificados indivuales.</p>
<p>Para ello introducimos nuestra DNS como muestro en el video adjunto.</p>
<p>Seleccionamos la casilla <strong>DNS Challenge</strong> y del listado clicamos en <strong>DuckDNS</strong> como proveedor.</p>
<p>En las opciones de configuración debemos de proveer el <strong>Token</strong> del servicio <em>DuckDNS</em>:</p>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm03.mp4" type="video/mp4" />
</video>
</div>
<p>Tras finalizar, tendremos configurado el certificado comodín de forma satisfactoria y con renovación automática.</p>
<figure>
<a href="/assets/images/posts/npm03.png"><img src="/assets/images/posts/npm03.png" /></a>
</figure>
<h3 id="microservicios">Microservicios</h3>
<p>Llega el turno de agregar nuestro microservicios para externalizarlos:</p>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm04.mp4" type="video/mp4" />
</video>
</div>
<p>Como ejemplo, planteo dos microservicios y las diferencias a la hora de configurarlos en la pestaña <strong>detalles</strong>:</p>
<figure class="half">
<a href="/assets/images/posts/npm04.png"><img src="/assets/images/posts/npm04.png" /></a>
<a href="/assets/images/posts/npm05.png"><img src="/assets/images/posts/npm05.png" /></a>
</figure>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">Domain Names</code></td>
<td>Nombre que elegimos para el <strong>microservicio + DNS</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">Scheme</code></td>
<td>Elegimos si la configuración la realiza de forma interna por <strong>HTTP o HTTPS</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">Forward Hostname / IP</code></td>
<td>Definimos la <strong>IP de nuestra red</strong> donde se aloja el servicio</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">Forward Port</code></td>
<td>Puerto de comunicación del <strong>microservicio</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">Cache Assets</code></td>
<td>Habilitamos el uso de cache</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">Block Common Exploits</code></td>
<td>Habilitamos bloqueos contra ataques genéricos</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">Websockets Support</code></td>
<td>Habilitamos la interacción Web con el microservicio, <strong>no siempre requerido</strong></td>
</tr>
</tbody>
</table>
<p>A continuación configuramos el certificado <strong>SSL</strong> antes de hacer clic en <em>Save</em> y aplicamos reglas de seguridad:</p>
<div class="lordvideo">
<video style="display:block; width:100%; height:auto;" controls="" loop="loop">
<source src="/assets/videos/npm05.mp4" type="video/mp4" />
</video>
</div>
<table class="notice--warning">
<thead>
<tr>
<th>Parámetro</th>
<th>Función</th>
</tr>
</thead>
<tbody>
<tr>
<td><code class="language-plaintext highlighter-rouge">SSL Certificate</code></td>
<td>Seleccionamos el <strong>certificado comodín</strong> que anteriormente configuramos</td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">Force SSL</code></td>
<td><strong>Forzamos</strong> que toda la comunicación externa sea a traves del <strong>certificado SSL</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">HTTP/2 Support</code></td>
<td>Habilitamos compatibilidad con protocolo <strong>HTTP 2.0</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">HSTS Enable</code></td>
<td><strong>Forzamos</strong> la comunicación a traves de <strong>HTTPS en dominio principal</strong></td>
</tr>
<tr>
<td><code class="language-plaintext highlighter-rouge">HSTS Subdomains</code></td>
<td><strong>Forzamos</strong> la comunicación a traves de <strong>HTTPS en subdominios</strong></td>
</tr>
</tbody>
</table>
<blockquote>
<p>Y listo!</p>
</blockquote>LordpedalNginx Proxy Manager en adelante NPM, es un Proxy inverso con el cual podremos redirigir las solicitudes a las distintas aplicaciones del sistema a un servicio web.