Jekyll2022-09-04T20:01:50+02:00https://www.danielmartingonzalez.com/feed.xmldanimart1991’s BlogOne blog more! Another post, another article.Daniel Martín GonzálezIntegrating a UPS in our server2022-08-18T00:00:00+02:002022-08-18T00:00:00+02:00https://www.danielmartingonzalez.com/en/integrating-ups-server<p>Our server is still an electronic device, and although <a href="https://www.danielmartingonzalez.com/en/backups-towards-docker/">we have protected your information by software through backup copies</a>, it is appropriate to also protect the hardware. We do not want the data to be corrupted or any electronic component damaged and we have to replace it due to a power surge or a simple power outage.</p>
<p><strong>UPS (Uninterruptible Power Supplies)</strong> arise from this need. In a very brief way, they are batteries that, placed between our electronic devices and the current, not only protect the devices from possible problems in the electrical supply, but also, in the event of a power outage, offer energy for a reasonable time so that we can safeguard the data, shut down the device correctly and avoid problems.</p>
<p>Although, the objective of this article is not to describe what a UPS is, what types exist, what you have to look for when you buy one… but the integration of it in our server to be able to monitor the information it offers and to be able to carry out different functions when we are interested in an automated way. I do recommend analyzing that the UPS we buy can be integrated via USB, since not all of them are.</p>
<p>Although compatible with many brands and models (which we will see later), for this tutorial we are going to integrate the <a href="https://amzn.to/3JYuON6"><strong>Salicru SPS 900 ONE</strong></a> model using <a href="https://networkupstools.org/"><strong><em>NUT</em> (<em>Network UPS Tools</em>)</strong></a>.</p>
<h2 id="nut-server">NUT Server</h2>
<p><a href="https://networkupstools.org/"><em>NUT</em> (<em>Network UPS Tools</em>)</a> consists of two well-differentiated parts, a <strong>software in server mode</strong>, which obtains the data from the UPS, and a <strong>software in client mode</strong>, which displays the data obtained by requesting that information from the server.</p>
<p>We need to know which USB device our server has assigned to the UPS. To do this, in the terminal of the server that is going to manage the UPS, execute <code class="language-plaintext highlighter-rouge">lsusb</code>, connect the USB cable from the UPS to the server and launch the command again. We will see a new entry:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>...
Bus 002 Device 001: ID 0665:5161 Cypress Semiconductor USB to Serial
...
</code></pre></div></div>
<p>Take note of <em>Bus</em> (<code class="language-plaintext highlighter-rouge">002</code>) and <em>Device</em> (<code class="language-plaintext highlighter-rouge">001</code>). With this information we will get the path of the device. Following the example, it would be: <code class="language-plaintext highlighter-rouge">/dev/bus/usb/002/001</code>.</p>
<p>Next, and as usual in the blog, <a href="https://www.danielmartingonzalez.com/en/docker-and-portainer-in-debian/">we are going to instantiate a <em>Docker</em> container</a> in order to create a service with the purpose we are looking for. In this case, create a <em>Network UPS Tools</em> server.</p>
<p>Execute the following command in a terminal:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker run <span class="nt">-d</span> <span class="nt">--name</span><span class="o">=</span>nut-upsd <span class="nt">--hostname</span><span class="o">=</span>nut-upsd <span class="nt">--restart</span><span class="o">=</span>always <span class="nt">--network</span><span class="o">=</span>host <span class="nt">--device</span> /dev/bus/usb/002/001 <span class="nt">-e</span> <span class="nv">UPS_NAME</span><span class="o">=</span><span class="s2">"server_ups"</span> <span class="nt">-e</span> <span class="nv">UPS_DESC</span><span class="o">=</span><span class="s2">"Server - Salicru SPS 900 ONE"</span> <span class="nt">-e</span> <span class="nv">UPS_DRIVER</span><span class="o">=</span><span class="s2">"blazer_usb"</span> <span class="nt">-e</span> <span class="nv">UPS_PORT</span><span class="o">=</span><span class="s2">"auto"</span> <span class="nt">-e</span> <span class="nv">API_USER</span><span class="o">=</span><span class="s2">"upsmon"</span> <span class="nt">-e</span> <span class="nv">API_PASSWORD</span><span class="o">=</span><span class="s2">"123456789ABCDEFGH"</span> <span class="nt">-e</span> <span class="nv">ADMIN_PASSWORD</span><span class="o">=</span><span class="s2">"123456789ABCDEFGH"</span> <span class="nt">-e</span> <span class="nv">SHUTDOWN_CMD</span><span class="o">=</span><span class="s2">"echo 'Home has no current. Proceeding to shut down...'"</span> upshift/nut-upsd
</code></pre></div></div>
<p>We are going to explain each of the parameters that have been used:</p>
<ul>
<li><code class="language-plaintext highlighter-rouge">docker run -d</code>: Create a container with the following configuration if it doesn’t exist and start it in the background.</li>
<li><code class="language-plaintext highlighter-rouge">--name=nut-upsd</code>: The name of the container. It is important because we can have several containers instantiated from the same image.</li>
<li><code class="language-plaintext highlighter-rouge">--hostname=nut-upsd</code>: Is the name of the host to use inside the container.</li>
<li><code class="language-plaintext highlighter-rouge">--restart=always</code>: Restart the container automatically if it stops. If it is stopped manually, it is only started when the container is manually started or the <em>Docker</em> service is restarted.</li>
<li><code class="language-plaintext highlighter-rouge">--network=host</code>: The host network uses the <em>IP</em> address of the server, so a container’s network appears to be the server itself rather than separate.</li>
<li><code class="language-plaintext highlighter-rouge">--device /dev/bus/usb/002/001</code>: We give the container access to the <em>USB</em> device that we discovered earlier.</li>
<li><code class="language-plaintext highlighter-rouge">-e UPS_NAME="server_ups -e UPS_DESC="Server - Salicru SPS 900</code>: It is the name and description that we want to give to the UPS, in case we have more than one.</li>
<li><code class="language-plaintext highlighter-rouge">-e UPS_DRIVER="blazer_usb"</code>: The <em>driver</em> that we are going to use with the UPS. Each brand usually has a different <em>driver</em>. Read more below.</li>
<li><code class="language-plaintext highlighter-rouge">-e UPS_PORT="auto"</code>: Indicates the UPS port if by chance you need a specific port. It is not usually necessary to modify this parameter.</li>
<li><code class="language-plaintext highlighter-rouge">-e API_USER="upsmon" -e API_PASSWORD="123456789ABCDEFGH"</code>: Indicates the username and password that we want to use for data read-only mode. It is the user that we will use normally.</li>
<li><code class="language-plaintext highlighter-rouge">-e ADMIN_PASSWORD="123456789ABCDEFGH"</code>: Indicates the password used in administrator mode to perform write functions on the server and the UPS.</li>
<li><code class="language-plaintext highlighter-rouge">-e SHUTDOWN_CMD="echo 'Home has no current. Proceeding to shut down...'"</code>: <em>script</em>/command to run when battery is VERY low. For example, perform a server shutdown.</li>
<li><code class="language-plaintext highlighter-rouge">upshift/nut-upsd</code>: Indicates the image used to mount the container. If no version is indicated, it will take the latest stable version.</li>
</ul>
<p>To know which <code class="language-plaintext highlighter-rouge">UPS_DRIVER</code> to use, you can consult <a href="https://networkupstools.org/stable-hcl.html">the <em>NUT</em> compatibility list</a>, in case you can’t find it, there is a <a href="https://networkupstools.org/ddl/">list of devices tested by the community</a>.</p>
<blockquote>
<p>You also have an example for <em>Docker Compose</em> <a href="https://github.com/danimart1991/docker-compose-files/tree/master/nut-upsd">here</a>.</p>
</blockquote>
<h2 id="clients">Clients</h2>
<p>Once the server is instantiated, we can use any client to query data or perform different functions.</p>
<p>The server container itself includes a client. If we have enough knowledge of <em>Docker</em>, we can do a *Docker Attach *and execute <code class="language-plaintext highlighter-rouge">upsd <UPS_NAME></code> (<code class="language-plaintext highlighter-rouge">UPS_NAME</code> is the name of the UPS that we have indicated when instantiating the server). Commands can also be run with <a href="https://networkupstools.org/docs/man/upscmd.html">upscmd</a> and <a href="https://networkupstools.org/docs/man/upsrw.html">upsrw</a>.</p>
<h3 id="docker-webnut">docker-webnut</h3>
<p><a href="/assets/posts/en/integrating-ups-server/docker-webnut.png"><img src="/assets/posts/en/integrating-ups-server/docker-webnut.png" alt="docker-webnut client preview" /></a></p>
<p><a href="https://github.com/edgd1er/docker-webnut"><strong><em>docker-webnut</em></strong></a> is another simple client for querying data. We can instantiate a <em>Docker</em> container with the following command:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker run <span class="nt">-d</span> <span class="nt">--name</span><span class="o">=</span>webnut <span class="nt">--hostname</span><span class="o">=</span>webnut <span class="nt">--restart</span><span class="o">=</span>always <span class="nt">--network</span><span class="o">=</span>host <span class="nt">-e</span> <span class="nv">UPS_HOST</span><span class="o">=</span><span class="s2">"<IP_SERVIDOR>"</span> <span class="nt">-e</span> <span class="nv">UPS_PORT</span><span class="o">=</span><span class="s2">"3493"</span> <span class="nt">-e</span> <span class="nv">UPS_USER</span><span class="o">=</span><span class="s2">"upsmon"</span> <span class="nt">-e</span> <span class="nv">UPS_PASSWORD</span><span class="o">=</span><span class="s2">"123456789ABCDEFGH"</span> edgd1er/webnut:latest
</code></pre></div></div>
<p>We only need to indicate the <em>IP</em> of the machine to which the UPS is connected via <em>USB</em> (in our example, the <em>IP</em> of the server), the username and password that we indicated when instantiating the <em>NUT</em> server, and the port, which is <code class="language-plaintext highlighter-rouge">3493</code> by default.</p>
<p>Next, we access a Web browser and indicate the address <code class="language-plaintext highlighter-rouge">http://<Server_IP>:3494</code>.</p>
<h3 id="nut-webui">nut-webui</h3>
<p><a href="/assets/posts/en/integrating-ups-server/nut-webui-dashboard-01.png"><img src="/assets/posts/en/integrating-ups-server/nut-webui-dashboard-01.png" alt="nut-webui client preview" /></a></p>
<p><a href="/assets/posts/en/integrating-ups-server/nut-webui-dashboard-02.png"><img src="/assets/posts/en/integrating-ups-server/nut-webui-dashboard-02.png" alt="nut-webui client preview detail" /></a></p>
<p>The <a href="https://github.com/gpdm/nut"><strong><em>nut-webui</em></strong></a> client is somewhat more complex. We need to previously create the files:</p>
<ul>
<li><code class="language-plaintext highlighter-rouge">upsset.conf</code>
<ul>
<li>Uncomment the line to have <code class="language-plaintext highlighter-rouge">http://<Server_IP>:6544/cgi-bin/nut/upsset.cgi</code></li>
<li>User <em>admin</em>, password, the one generated automatically in the <em>Docker Log</em> or indicated in the creation of the <em>NUT</em> server.</li>
</ul>
</li>
<li><code class="language-plaintext highlighter-rouge">hosts.conf</code>
<ul>
<li>Enter the UPS data.</li>
</ul>
</li>
<li><code class="language-plaintext highlighter-rouge">upsstats.html</code></li>
<li><code class="language-plaintext highlighter-rouge">upsstats-single.html</code></li>
</ul>
<blockquote>
<p>Configuration and sample files: <a href="https://github.com/gpdm/nut/tree/master/nut-webui/files/etc/nut">https://github.com/gpdm/nut/tree/master/nut-webui/files/etc/nut</a></p>
</blockquote>
<p>And include them in a folder that we will use when instantiating the container with the following command:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker run <span class="nt">-d</span> <span class="nt">--name</span><span class="o">=</span>nut-webui <span class="nt">--hostname</span><span class="o">=</span>nut-webui <span class="nt">--restart</span><span class="o">=</span>always <span class="nt">-p</span> 6495:80 <span class="nt">-v</span> <PATH_FOLDER_CONFIGURATION_FILES>:/etc/nut gpdm/nut-webui:latest
</code></pre></div></div>
<p>Next, we access a <em>Web</em> browser and indicate the address <code class="language-plaintext highlighter-rouge">http://<Server_IP>:3495</code>.</p>
<h2 id="bonus-homeassistant-integration">Bonus: HomeAssistant integration</h2>
<p>We can use <a href="https://www.home-assistant.io/"><strong><em>Home Assistant</em></strong></a> as a client, monitor the values offered by the server and perform different automations depending on the status of the sensors created with these values.</p>
<p>Surely, the automatic detection system of <em>Home Assistant</em> detects <em>NUT</em> in our network, but if it is not the case, it is enough to add the integration from <code class="language-plaintext highlighter-rouge">Settings -> Devices & Services -> Add Integration -> Network UPS Tools (NUT)</code>.</p>
<p><a href="/assets/posts/en/integrating-ups-server/nut-homeassistant-config.png"><img src="/assets/posts/en/integrating-ups-server/nut-homeassistant-config.png" alt="NUT Configuration in Home Assistant" /></a></p>
<p>We indicate the data of our <em>NUT</em> server as we have done in other clients and that’s it.</p>
<p><a href="/assets/posts/en/integrating-ups-server/nut-homeassistant-sensors.png"><img src="/assets/posts/en/integrating-ups-server/nut-homeassistant-sensors.png" alt="Home Assistant NUT UPS Sensors" /></a></p>
<h2 id="bonus-2-checkmk-integration">Bonus 2: CheckMK integration</h2>
<p>Although we have not talked about <a href="https://checkmk.com/"><strong><em>CheckMK</em></strong></a> in this blog, it is a monitoring and alert system that I use frequently. If you are familiar with it, you may be interested in the following <em>Plugin</em> to monitor <em>UPS</em> data: https://github.com/danimart1991/checkmk_nut</p>
<p><a href="/assets/posts/en/integrating-ups-server/nut-checkmk-sensors.png"><img src="/assets/posts/en/integrating-ups-server/nut-checkmk-sensors.png" alt="CheckMK NUT UPS Sensors" /></a></p>
<h2 id="references">References</h2>
<ul>
<li><a href="https://blog.shadypixel.com/monitoring-a-ups-with-nut-on-debian-or-ubuntu-linux/">Random Bits - Monitoring a UPS with nut on Debian or Ubuntu Linux</a></li>
<li><a href="https://domology.es/integrar-un-sai-en-home-assistant/">Domology - Integrar un SAI en Home Assistant</a></li>
<li><a href="https://networkupstools.org/documentation.html">Network UPS Tools - Documentation</a></li>
<li><a href="https://blog.minodudd.com/2013/10/23/ups-monitoring-with-nut-nagios-and-check_mk/">Tinkerings - UPS monitoring with NUT, Nagios and Check_MK</a></li>
<li><a href="https://www.profesionalreview.com/2019/02/23/que-es-sai/">Professional Review - SAI: Qué es, para qué sirve y que tipos hay en el mercado</a></li>
</ul>Daniel Martín GonzálezOur server is still an electronic device, and although we have protected your information by software through backup copies, it is appropriate to also protect the hardware. We do not want the data to be corrupted or any electronic component damaged and we have to replace it due to a power surge or a simple power outage.Integrando un SAI en nuestro servidor2022-08-18T00:00:00+02:002022-08-18T00:00:00+02:00https://www.danielmartingonzalez.com/es/integrando-sai-servidor<p>Nuestro servidor, no deja de ser un equipo electrónico, y si bien, <a href="https://www.danielmartingonzalez.com/es/copias-de-seguridad-para-con-docker/">hemos protegido su información por <em>software</em> mediante copias de seguridad</a>, lo apropiado es proteger también el <em>hardware</em>. No queremos que, por una subida de tensión, o por un simple corte de luz, los datos queden corruptos o cualquier componente electrónico quede dañado y tengamos que sustituirlo.</p>
<p><strong>Los SAI (Sistemas de Alimentación Ininterrumpida)</strong> surgen ante esta necesidad. De manera muy resumida, son baterías que, colocadas entre nuestros dispositivos electrónicos y la corriente, no solo protege a los dispositivos de posibles problemas en el suministro eléctrico, si no que también, ante un corte, ofrecen energía un tiempo prudencial para que podamos salvaguardar los datos, apagar el dispositivo correctamente y evitar problemas.</p>
<p>Si bien, el objetivo de este artículo no es el de describir que es un SAI, que tipos existen, que has de buscar cuando compres uno… si no la integración de éste en nuestro servidor para poder monitorizar la información que ofrece y poder llevar a cabo distintas funciones cuando nos interese de manera automatizada. Si recomiendo, analizar que el SAI que compremos sea integrable por <em>USB</em>, ya que no todos lo son.</p>
<p>Aunque compatible con muchas marcas y modelos (que veremos más adelante), para este tutorial vamos a integrar el modelo <a href="https://amzn.to/3JYuON6"><strong>Salicru SPS 900 ONE</strong></a> haciendo uso de <a href="https://networkupstools.org/"><strong><em>NUT</em> (<em>Network UPS Tools</em>)</strong></a>.</p>
<h2 id="servidor-nut">Servidor NUT</h2>
<p><a href="https://networkupstools.org/"><em>NUT</em> (<em>Network UPS Tools</em>)</a> consta de dos partes bien diferenciadas, <strong>un software en modo servidor</strong>, el cual obtiene los datos del SAI, y <strong>un software en modo cliente</strong>, que muestra los datos obtenidos pidiendo al servidor esa información.</p>
<p>Necesitamos conocer que dispositivo <em>USB</em> ha asignado nuestro servidor al SAI. Para ello, en la terminal del servidor que va a gestionar el SAI ejecutamos <code class="language-plaintext highlighter-rouge">lsusb</code>, enchufamos un cable <em>USB</em> del <em>SAI</em> al servidor y lanzamos el comando de nuevo. Veremos una nueva entrada:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>...
Bus 002 Device 001: ID 0665:5161 Cypress Semiconductor USB to Serial
...
</code></pre></div></div>
<p>Apuntamos <em>Bus</em> (<code class="language-plaintext highlighter-rouge">002</code>) y <em>Device</em> (<code class="language-plaintext highlighter-rouge">001</code>). Con esta información sacaremos la ruta del <code class="language-plaintext highlighter-rouge">device</code>. Siguiendo el ejemplo, quedaría: <code class="language-plaintext highlighter-rouge">/dev/bus/usb/002/001</code>.</p>
<p>A continuación, y como viene siendo habitual en el blog, <a href="https://www.danielmartingonzalez.com/es/docker-y-portainer-en-debian/">vamos a instanciar un contenedor <em>Docker</em></a> con el fin de crear un servicio con el propósito que buscamos. En este caso, crear un servidor <em>Network UPS Tools</em>.</p>
<p>Ejecutamos el siguiente comando en un terminal:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker run <span class="nt">-d</span> <span class="nt">--name</span><span class="o">=</span>nut-upsd <span class="nt">--hostname</span><span class="o">=</span>nut-upsd <span class="nt">--restart</span><span class="o">=</span>always <span class="nt">--network</span><span class="o">=</span>host <span class="nt">--device</span> /dev/bus/usb/002/001 <span class="nt">-e</span> <span class="nv">UPS_NAME</span><span class="o">=</span><span class="s2">"server_ups"</span> <span class="nt">-e</span> <span class="nv">UPS_DESC</span><span class="o">=</span><span class="s2">"Server - Salicru SPS 900 ONE"</span> <span class="nt">-e</span> <span class="nv">UPS_DRIVER</span><span class="o">=</span><span class="s2">"blazer_usb"</span> <span class="nt">-e</span> <span class="nv">UPS_PORT</span><span class="o">=</span><span class="s2">"auto"</span> <span class="nt">-e</span> <span class="nv">API_USER</span><span class="o">=</span><span class="s2">"upsmon"</span> <span class="nt">-e</span> <span class="nv">API_PASSWORD</span><span class="o">=</span><span class="s2">"123456789ABCDEFGH"</span> <span class="nt">-e</span> <span class="nv">ADMIN_PASSWORD</span><span class="o">=</span><span class="s2">"123456789ABCDEFGH"</span> <span class="nt">-e</span> <span class="nv">SHUTDOWN_CMD</span><span class="o">=</span><span class="s2">"echo 'Home has no current. Proceeding to shut down...'"</span> upshift/nut-upsd
</code></pre></div></div>
<p>Vamos a explicar cada uno de los parámetros que se han usado:</p>
<ul>
<li><code class="language-plaintext highlighter-rouge">docker run -d</code>: Crea un contenedor con la siguiente configuración si no existe y lo arranca en segundo plano.</li>
<li><code class="language-plaintext highlighter-rouge">--name=nut-upsd</code>: El nombre del contenedor. Es importante pues podemos tener varios contenedores instanciados desde la misma imagen.</li>
<li><code class="language-plaintext highlighter-rouge">--hostname=nut-upsd</code>: Es el nombre del host que se va a usar dentro del contenedor.</li>
<li><code class="language-plaintext highlighter-rouge">--restart=always</code>: Reinicia el contenedor automáticamente si se para. Si se para manualmente, solo es inciiado cuando el contenedor se inicie manualmente o el servicio <em>Docker</em> sea reiniciado.</li>
<li><code class="language-plaintext highlighter-rouge">--network=host</code>: La red host utiliza la dirección <em>IP</em> del servidor, de modo que la red de un contenedor parece ser el propio servidor en lugar de estar separado.</li>
<li><code class="language-plaintext highlighter-rouge">--device /dev/bus/usb/002/001</code>: Damos acceso al contenedor al dispositivo <em>USB</em> que hemos descubierto antes.</li>
<li><code class="language-plaintext highlighter-rouge">-e UPS_NAME="server_ups -e UPS_DESC="Server - Salicru SPS 900</code>: Es el nombre y descripción que queremos dar al SAI, por si tenemos más de uno.</li>
<li><code class="language-plaintext highlighter-rouge">-e UPS_DRIVER="blazer_usb"</code>: El <em>driver</em> que vamos a usar con el SAI. Cada marca suele tener un <em>driver</em> diferente. Lee más abajo.</li>
<li><code class="language-plaintext highlighter-rouge">-e UPS_PORT="auto"</code>: Indica el puerto del SAI si por un casual necesita un puerto específico. No suele ser necesario modificar este parámetro.</li>
<li><code class="language-plaintext highlighter-rouge">-e API_USER="upsmon" -e API_PASSWORD="123456789ABCDEFGH"</code>: Indica el usuario y contraseña que queremos usar para el modo de solo lectura de datos. Es el usuario que usaremos normalmente.</li>
<li><code class="language-plaintext highlighter-rouge">-e ADMIN_PASSWORD="123456789ABCDEFGH"</code>: Indica la contraseña usada en el modo administrador para realizar funciones de escritura en el servidor y en el SAI.</li>
<li><code class="language-plaintext highlighter-rouge">-e SHUTDOWN_CMD="echo 'Home has no current. Proceeding to shut down...'"</code>: <em>script</em>/comando a ejecutar cuando la batería sea MUY baja. Por ejemplo, realizar un apagado del servidor.</li>
<li><code class="language-plaintext highlighter-rouge">upshift/nut-upsd</code>: Indica la imagen usada para montar el contenedor. Si no se indica versión cogerá la última versión estable.</li>
</ul>
<p>Para saber que <code class="language-plaintext highlighter-rouge">UPS_DRIVER</code> usar, se puede consultar <a href="https://networkupstools.org/stable-hcl.html">la lista de compatibilidad de <em>NUT</em></a>, en el caso de no encontrarlo, hay una lista de <a href="https://networkupstools.org/ddl/">dispositivos probados por la comunidad</a>.</p>
<blockquote>
<p>También dispones de un ejemplo para <em>Docker Compose</em> <a href="https://github.com/danimart1991/docker-compose-files/tree/master/nut-upsd">aquí</a>.</p>
</blockquote>
<h2 id="clientes">Clientes</h2>
<p>Una vez instanciado el servidor, podremos usar cualquier cliente para consultar datos o realizar diferentes funciones.</p>
<p>El propio contenedor del servidor incluye un cliente. Si tenemos conocimientos suficientes de <em>Docker</em>, podemos realizar un <em>Docker Attach</em> y ejecutar <code class="language-plaintext highlighter-rouge">upsd <UPS_NAME></code> (<code class="language-plaintext highlighter-rouge">UPS_NAME</code> es el nombre del SAI que hemos indicado al instanciar el servidor). También se pueden ejecutar comandos con <a href="https://networkupstools.org/docs/man/upscmd.html">upscmd</a> y <a href="https://networkupstools.org/docs/man/upsrw.html">upsrw</a>.</p>
<h3 id="docker-webnut">docker-webnut</h3>
<p><a href="/assets/posts/es/integrando-sai-servidor/docker-webnut.png"><img src="/assets/posts/es/integrando-sai-servidor/docker-webnut.png" alt="Vista previa cliente docker-webnut" /></a></p>
<p><a href="https://github.com/edgd1er/docker-webnut"><strong><em>docker-webnut</em></strong></a> es otro cliente sencillo para consultar datos. Podemos instanciar un contenedor <em>Docker</em> con el siguiente comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker run <span class="nt">-d</span> <span class="nt">--name</span><span class="o">=</span>webnut <span class="nt">--hostname</span><span class="o">=</span>webnut <span class="nt">--restart</span><span class="o">=</span>always <span class="nt">--network</span><span class="o">=</span>host <span class="nt">-e</span> <span class="nv">UPS_HOST</span><span class="o">=</span><span class="s2">"<IP_SERVIDOR>"</span> <span class="nt">-e</span> <span class="nv">UPS_PORT</span><span class="o">=</span><span class="s2">"3493"</span> <span class="nt">-e</span> <span class="nv">UPS_USER</span><span class="o">=</span><span class="s2">"upsmon"</span> <span class="nt">-e</span> <span class="nv">UPS_PASSWORD</span><span class="o">=</span><span class="s2">"123456789ABCDEFGH"</span> edgd1er/webnut:latest
</code></pre></div></div>
<p>Solo necesitamos indicar la <em>IP</em> de la máquina a la que está conectado por <em>USB</em> el SAI (en nuestro ejemplo, la <em>IP</em> del servidor), el usuario y contraseña que hemos indicado al instanciar el servidor <em>NUT</em> y el puerto, que por defecto es <code class="language-plaintext highlighter-rouge">3493</code>.</p>
<p>A continuación, accedemos a un navegador <em>Web</em> e indicamos la dirección <code class="language-plaintext highlighter-rouge">http://<IP_Servidor>:3494</code>.</p>
<h3 id="nut-webui">nut-webui</h3>
<p><img src="/assets/posts/es/integrando-sai-servidor/nut-webui-dashboard-01.png" alt="Vista previa cliente nut-webui" />](/assets/posts/es/integrando-sai-servidor/nut-webui-dashboard-01.png)</p>
<p><img src="/assets/posts/es/integrando-sai-servidor/nut-webui-dashboard-02.png" alt="Vista previa cliente detalle nut-webui" />](/assets/posts/es/integrando-sai-servidor/nut-webui-dashboard-02.png)</p>
<p>El cliente <a href="https://github.com/gpdm/nut"><strong><em>nut-webui</em></strong></a> es algo más complejo. Necesitamos crear previamente los archivos:</p>
<ul>
<li><code class="language-plaintext highlighter-rouge">upsset.conf</code>
<ul>
<li>Descomentar la línea para disponer de <code class="language-plaintext highlighter-rouge">http://<IP_Servidor>:6544/cgi-bin/nut/upsset.cgi</code></li>
<li>Usuario <em>admin</em>, contraseña, la generada automáticamente en el <em>Log de Docker</em> o indicada en la creación del servidor <em>NUT</em>.</li>
</ul>
</li>
<li><code class="language-plaintext highlighter-rouge">hosts.conf</code>
<ul>
<li>Poner dentro los datos del SAI.</li>
</ul>
</li>
<li><code class="language-plaintext highlighter-rouge">upsstats.html</code></li>
<li><code class="language-plaintext highlighter-rouge">upsstats-single.html</code></li>
</ul>
<blockquote>
<p>Configuración y archivos de ejemplo: <a href="https://github.com/gpdm/nut/tree/master/nut-webui/files/etc/nut">https://github.com/gpdm/nut/tree/master/nut-webui/files/etc/nut</a></p>
</blockquote>
<p>E incluirlos en una carpeta que usaremos al instanciar el contenedor con el siguiente comando:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker run <span class="nt">-d</span> <span class="nt">--name</span><span class="o">=</span>nut-webui <span class="nt">--hostname</span><span class="o">=</span>nut-webui <span class="nt">--restart</span><span class="o">=</span>always <span class="nt">-p</span> 6495:80 <span class="nt">-v</span> <RUTA_CARPETA_ARCHIVOS_CONFIGURACIÓN>:/etc/nut gpdm/nut-webui:latest
</code></pre></div></div>
<p>A continuación, accedemos a un navegador <em>Web</em> e indicamos la dirección <code class="language-plaintext highlighter-rouge">http://<IP_Servidor>:3495</code>.</p>
<h2 id="bonus-integración-en-home-assistant">Bonus: Integración en Home Assistant</h2>
<p>Podemos usar <a href="https://www.home-assistant.io/"><strong><em>Home Assistant</em></strong></a> como cliente, monitorizar los valores que ofrece el servidor y realizar diferentes automatizaciones dependiendo del estado de los sensores creados con estos valores.</p>
<p>Seguramente, el sistema de detección automático de <em>Home Assistant</em> detecte <em>NUT</em> en nuestra red, pero si no es el caso, basta con añadir la integración desde <code class="language-plaintext highlighter-rouge">Ajustes -> Dispositivos y Servicios -> Añadir Integración -> Network UPS Tools (NUT)</code>.</p>
<p><a href="/assets/posts/es/integrando-sai-servidor/nut-homeassistant-configuracion.png"><img src="/assets/posts/es/integrando-sai-servidor/nut-homeassistant-configuracion.png" alt="Configuracion de NUT en Home Assistant" /></a></p>
<p>Indicamos los datos de nuestro servidor <em>NUT</em> como hemos hecho en otros clientes y listo.</p>
<p><a href="/assets/posts/es/integrando-sai-servidor/nut-homeassistant-sensores.png"><img src="/assets/posts/es/integrando-sai-servidor/nut-homeassistant-sensores.png" alt="Sensores de SAI en Home Assistant" /></a></p>
<h2 id="bonus-2-integración-en-checkmk">Bonus 2: Integración en CheckMK</h2>
<p>Aunque no hemos hablado en este blog sobre <a href="https://checkmk.com/"><strong><em>CheckMK</em></strong></a>, es un sistema de monitorización y alertas que uso con frecuencia. Si estás familiarizado con él, puede interesarte el siguiente <em>Plugin</em> para poder monitorizar los datos del SAI: https://github.com/danimart1991/checkmk_nut</p>
<p><a href="/assets/posts/es/integrando-sai-servidor/nut-checkmk-sensores.png"><img src="/assets/posts/es/integrando-sai-servidor/nut-checkmk-sensores.png" alt="Sensores de SAI en CheckMK" /></a></p>
<h2 id="referencias">Referencias</h2>
<ul>
<li><a href="https://blog.shadypixel.com/monitoring-a-ups-with-nut-on-debian-or-ubuntu-linux/">Random Bits - Monitoring a UPS with nut on Debian or Ubuntu Linux</a></li>
<li><a href="https://domology.es/integrar-un-sai-en-home-assistant/">Domology - Integrar un SAI en Home Assistant</a></li>
<li><a href="https://networkupstools.org/documentation.html">Network UPS Tools - Documentation</a></li>
<li><a href="https://blog.minodudd.com/2013/10/23/ups-monitoring-with-nut-nagios-and-check_mk/">Tinkerings - UPS monitoring with NUT, Nagios and Check_MK</a></li>
<li><a href="https://www.profesionalreview.com/2019/02/23/que-es-sai/">Professional Review - SAI: Qué es, para qué sirve y que tipos hay en el mercado</a></li>
</ul>Daniel Martín GonzálezNuestro servidor, no deja de ser un equipo electrónico, y si bien, hemos protegido su información por software mediante copias de seguridad, lo apropiado es proteger también el hardware. No queremos que, por una subida de tensión, o por un simple corte de luz, los datos queden corruptos o cualquier componente electrónico quede dañado y tengamos que sustituirlo.Webmin: Managing a server from the browser2022-04-14T00:00:00+02:002022-04-14T00:00:00+02:00https://www.danielmartingonzalez.com/en/webmin-managing-server-from-browser<p>I don’t know much about <em>Unix</em> systems. While I can type some commands and move around its directories, it’s not something I’m used to or like to deal with. But I recognize that a <em>Linux</em> distribution is the best option to set up a server.</p>
<p><a href="/assets/posts/en/webmin-managing-server-from-browser/webmin-dashboard.png"><img src="/assets/posts/en/webmin-managing-server-from-browser/webmin-dashboard.png" alt="Webmin's System information start screen (Dashboard)" /></a></p>
<p><a href="https://webmin.com/"><strong><em>Webmin</em></strong></a> solves the management of a server in an elegant way, since it is a system configuration tool accessible via the web for <em>Unix</em> systems. With it, you can configure user accounts, view and edit files, view the status of system resources, and much more from the comfort of your browser. This application helps us eliminate the need to edit the configuration and service files manually and provides an interface to do it easily and with little tips.</p>
<blockquote>
<p><strong>WARNING</strong>: <em>Webmin</em> allows you to modify settings and data at the core level of the system, this means that before touching any module, it is advisable to read documentation about how it works and how it can affect our server.</p>
</blockquote>
<h2 id="installation-and-use">Installation and Use</h2>
<p>We are going to install <em>Webmin</em> on the system itself by <code class="language-plaintext highlighter-rouge">apt</code> package. The reason for doing it this way and not in a <em>Docker</em> container is because <em>Webmin</em> needs to have full access to the entire system, both files and services. Also, if for any reason the <em>Docker</em> service goes down, you can still use <em>Webmin</em> to fix the problem.</p>
<p>Assuming that your server has a distribution based on <em>Debian</em>, <em>Ubuntu</em> or <em>Mint</em>. Execute the following commands:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>wget <span class="nt">-qO</span> - http://www.webmin.com/jcameron-key.asc | <span class="nb">sudo </span>apt-key add -
<span class="nv">$ </span><span class="nb">sudo </span>sh <span class="nt">-c</span> <span class="s1">'echo "deb http://download.webmin.com/download/repository sarge contrib" > /etc/apt/sources.list.d/webmin.list'</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt <span class="nb">install </span>apt-transport-https <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt update
<span class="nv">$ </span><span class="nb">sudo </span>apt <span class="nb">install </span>webmin <span class="nt">-y</span>
</code></pre></div></div>
<blockquote>
<p>For the rest of the distributions and available installation types, you can consult <a href="http://doxfer.webmin.com/Webmin/Installation">this <em>Wiki</em></a>.</p>
</blockquote>
<p>And that’s all, finally, open a browser and access the address <code class="language-plaintext highlighter-rouge">https://<ip_of_your_server>:10000</code>. On the main screen (<em>Dashboard</em>) you will have summary information on the status of your server. In the bar on the left you will have different utilities to manage the server. Remember, before touching, it is convenient to read the documentation of that module and tool.</p>
<blockquote>
<p>It is possible that, when entering for the first time, a certificate error is displayed, agree to enter in a non-secure way.</p>
</blockquote>
<h2 id="references">References</h2>
<ul>
<li><a href="https://webmin.com">Webmin - Official Web</a></li>
<li><a href="https://doxfer.webmin.com/Webmin">Webmin - Wiki</a></li>
<li><a href="https://raiolanetworks.es/blog/webmin-usermin-virtualmin">Raiola Networks - Manual completo Webmin, Usermin y Virtualmin</a></li>
<li><a href="https://linuxize.com/post/how-to-install-webmin-on-debian-10/">Linuxize - How to Install Webmin on Debian 10 Linux</a></li>
</ul>Daniel Martín GonzálezI don’t know much about Unix systems. While I can type some commands and move around its directories, it’s not something I’m used to or like to deal with. But I recognize that a Linux distribution is the best option to set up a server.Webmin: Administrando un servidor desde el navegador2022-04-14T00:00:00+02:002022-04-14T00:00:00+02:00https://www.danielmartingonzalez.com/es/webmin-administrando-un-servidor-desde-navegador<p>No conozco mucho de sistemas <em>Unix</em>. Si bien puedo teclear algunos comandos y moverme por sus directorios, no es algo a lo que esté acostumbrado ni con lo que me guste lidiar. Pero reconozco, que una distribución <em>Linux</em> es la mejor opción para montar un servidor.</p>
<p><a href="/assets/posts/es/webmin-administrando-un-servidor-desde-navegador/webmin-dashboard.png"><img src="/assets/posts/es/webmin-administrando-un-servidor-desde-navegador/webmin-dashboard.png" alt="Pantalla de inicio de información del sistema en Webmin (Dashboard)" /></a></p>
<p><a href="https://webmin.com/"><strong><em>Webmin</em></strong></a> resuelve la gestión de un servidor de manera elegante, ya que se trata de una herramienta de configuración de sistemas accesible vía web para sistemas <em>Unix</em>. Con ella, puedes desde la comodidad del navegador configurar cuentas de usuario, visualizar y editar archivos, ver el estado de los recursos del sistema y un largo etcétera. Este aplicativo nos ayuda a eliminar la necesidad de editar los archivos de configuración y de los servicios manualmente y brinda una interfaz para hacerlo de manera sencilla y con pequeños consejos.</p>
<blockquote>
<p><strong>AVISO</strong>: <em>Webmin</em> permite modificar configuraciones y datos a nivel de núcleo del sistema, esto significa que antes de tocar cualquier módulo, conviene leer documentación acerca de cómo funciona y en que puede afectar a nuestro servidor.</p>
</blockquote>
<h2 id="instalación-y-uso">Instalación y Uso</h2>
<p>Vamos a instalar <em>Webmin</em> en el propio sistema por paquete <code class="language-plaintext highlighter-rouge">apt</code>. La razón de hacerlo así y no en un contenedor <em>Docker</em>, es porque <em>Webmin</em> necesita tener acceso completo a todo el sistema, tanto a archivos como a servicios. Además, si por cualquier motivo el servicio <em>Docker</em> cae, podremos seguir usando <em>Webmin</em> para solucionar el problema.</p>
<p>Suponiendo que nuestro servidor tiene una distribución basada en <em>Debian</em>, <em>Ubuntu</em> o <em>Mint</em>. Ejecutamos los siguientes comandos:</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>wget <span class="nt">-qO</span> - http://www.webmin.com/jcameron-key.asc | <span class="nb">sudo </span>apt-key add -
<span class="nv">$ </span><span class="nb">sudo </span>sh <span class="nt">-c</span> <span class="s1">'echo "deb http://download.webmin.com/download/repository sarge contrib" > /etc/apt/sources.list.d/webmin.list'</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt <span class="nb">install </span>apt-transport-https <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt update
<span class="nv">$ </span><span class="nb">sudo </span>apt <span class="nb">install </span>webmin <span class="nt">-y</span>
</code></pre></div></div>
<blockquote>
<p>Para el resto de distribuciones y tipos de instalación disponibles puedes consultar <a href="http://doxfer.webmin.com/Webmin/Installation">esta <em>Wiki</em></a>.</p>
</blockquote>
<p>Y poco más, por último, abrimos un navegador y accede a la dirección <code class="language-plaintext highlighter-rouge">https://<ip_de_tu_server>:10000</code>. En la pantalla principal (<em>Dashboard</em>) tendrás información resumida del estado de tu servidor. En la barra de la izquierda dispondrás de distintas utilidades para gestionar el servidor. Recuerda, antes de tocar, conviene leer la documentación de ese módulo y herramienta.</p>
<blockquote>
<p>Es posible que, al entrar por primera vez, se muestre un error de certificados, acepta entrar de manera no segura.</p>
</blockquote>
<h2 id="referencias">Referencias</h2>
<ul>
<li><a href="https://webmin.com">Webmin - Official Web</a></li>
<li><a href="https://doxfer.webmin.com/Webmin">Webmin - Wiki</a></li>
<li><a href="https://raiolanetworks.es/blog/webmin-usermin-virtualmin">Raiola Networks - Manual completo Webmin, Usermin y Virtualmin</a></li>
<li><a href="https://linuxize.com/post/how-to-install-webmin-on-debian-10/">Linuxize - How to Install Webmin on Debian 10 Linux</a></li>
</ul>Daniel Martín GonzálezNo conozco mucho de sistemas Unix. Si bien puedo teclear algunos comandos y moverme por sus directorios, no es algo a lo que esté acostumbrado ni con lo que me guste lidiar. Pero reconozco, que una distribución Linux es la mejor opción para montar un servidor.Your files from Windows, installing a Samba Server on Debian2022-01-07T00:00:00+01:002022-01-07T00:00:00+01:00https://www.danielmartingonzalez.com/en/samba-server-in-debian<p>Despite having different ways of <a href="https://www.danielmartingonzalez.com/en/online-file-browser-for-your-server/">accessing files on your server</a>, perhaps all of them become somewhat tedious if we are used to browsing through <em>Windows</em> folders. I have recently discovered a very simple way to have <a href="https://www.samba.org/"><strong>a <em>Samba</em> file server</strong></a> in <a href="https://www.debian.org/index.es.html"><em>Debian</em></a> and derivatives to be able to access the files on the server from a <em>Windows</em> client as if it were another folder.</p>
<p>Why do we need a <em>Samba</em> server to access files from <em>Windows</em> on a <em>Linux</em> server? Okay. By default, both systems use different file sharing protocols. <em>Samba</em> is a free implementation of the <em>Microsoft Windows File Sharing Protocol</em> (formerly called <em>SMB</em>, recently renamed <em>CIFS</em>) for <em>UNIX-like</em> systems.</p>
<h2 id="installation">Installation</h2>
<blockquote>
<p>Most of the following commands require <code class="language-plaintext highlighter-rouge">root</code> privileges to run. You can use <code class="language-plaintext highlighter-rouge">sudo</code> or log in as <code class="language-plaintext highlighter-rouge">root</code> user and save yourself typing the prefix in each command.</p>
</blockquote>
<p>Install the <em>Samba server</em> package:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>apt update
<span class="nv">$ </span><span class="nb">sudo </span>apt <span class="nb">install </span>samba <span class="nt">-y</span>
</code></pre></div></div>
<p>Enable the <em>Samba</em> service to start with the system:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>systemctl <span class="nb">enable </span>smbd
</code></pre></div></div>
<p>If you use the system <em>firewall</em>, you need to open the following ports:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>ufw allow 139
<span class="nv">$ </span><span class="nb">sudo </span>ufw allow 445
</code></pre></div></div>
<p>Restart the <code class="language-plaintext highlighter-rouge">smbd</code> service and check that it’s running:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>systemctl restart smbd
<span class="nv">$ </span><span class="nb">sudo </span>systemctl status smbd
? smbd.service - Samba SMB Daemon
...
Status: <span class="s2">"smbd: ready to serve connections..."</span>
...
</code></pre></div></div>
<h2 id="setting-up-samba-share">Setting up Samba Share</h2>
<p>Edit the <code class="language-plaintext highlighter-rouge">smb.conf</code> file with the command <code class="language-plaintext highlighter-rouge">sudo nano /etc/samba/smb.conf</code>, adding the following to the end of the document:</p>
<div class="language-config highlighter-rouge"><div class="highlight"><pre class="highlight"><code>[<span class="n">media</span>]
<span class="n">comment</span> = <span class="n">media</span> <span class="n">folder</span>
<span class="n">path</span> = /<span class="n">media</span>
<span class="n">writeable</span> = <span class="n">yes</span>
<span class="n">browsable</span> = <span class="n">yes</span>
<span class="n">public</span> = <span class="n">no</span>
<span class="n">valid</span> <span class="n">users</span> = <span class="n">danimart1991</span>, <span class="n">root</span>
</code></pre></div></div>
<p>I attach an explanation of each line:</p>
<ul>
<li><code class="language-plaintext highlighter-rouge">[media]</code>: It is the short name that describes what we are going to share. An identifier.</li>
<li><code class="language-plaintext highlighter-rouge">comment</code>: A comment to describe what we are sharing.</li>
<li><code class="language-plaintext highlighter-rouge">path</code>: The path of the folder we want to share.</li>
<li><code class="language-plaintext highlighter-rouge">writeable</code>: Indicates if we want the folder to be read-only or if you want to allow writes and deletions to be carried out on it.</li>
<li><code class="language-plaintext highlighter-rouge">browsable</code>: If this share is seen in the list of available shares in a network view and in the navigation list.</li>
<li><code class="language-plaintext highlighter-rouge">public</code>: Indicates if the folder does NOT need a password to access it.</li>
<li><code class="language-plaintext highlighter-rouge">valid users</code>: List of users who will have access to the folder.</li>
</ul>
<blockquote>
<p>You can see more options in the <a href="https://www.samba.org/samba/docs/current/man-html/smb.conf.5.html">documentation of the configuration file</a>.</p>
</blockquote>
<p>We save the file with the <code class="language-plaintext highlighter-rouge">F3</code> key and exit with <code class="language-plaintext highlighter-rouge">F2</code>.</p>
<h2 id="setting-up-users">Setting up Users</h2>
<p>As you can see, I have indicated in the <code class="language-plaintext highlighter-rouge">valid users</code> field which users can access the files. These users must have access to the shared folder and its files, otherwise they will not be able to see them when access it from <em>Windows</em>.</p>
<p>In addition, these users have to be created on our server. If not, just use the command:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>useradd danimart1991
</code></pre></div></div>
<p>Next. You have to declare that user in <em>Samba</em> and assign a unique password for this service. For this, use the following command:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>smbpasswd <span class="nt">-a</span> danimart1991
New SMB password: xxxxxxxx
Retype new SMB password: xxxxxxxx
</code></pre></div></div>
<p>Finally, restart the service:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>systemctl restart smbd
</code></pre></div></div>
<h2 id="conclusion">Conclusion</h2>
<p>We have already configured our <em>Samba</em> server for access from <em>Windows</em>. It is enough to open a <em>File Explorer</em>, write the server address and access indicating the credentials that have been previously created.</p>
<p><a href="/assets/posts/en/samba-server-in-debian/windows-samba.png"><img src="/assets/posts/en/samba-server-in-debian/windows-samba.png" alt="Server Access from Windows with Samba" /></a></p>
<p>Now you will have quick and easy access from your <em>Windows</em> devices to the server folders.</p>
<h2 id="references">References</h2>
<ul>
<li>Thanks to José Antonio Simancas (<em>JASimancas</em>)</li>
<li><a href="https://www.samba.org/">Samba</a></li>
<li><a href="https://www.server-world.info/en/note?os=Debian_11&p=samba&f=1">Server World - Debian 11 Bullseye : Samba</a></li>
<li><a href="https://www.linuxito.com/gnu-linux/nivel-basico/1233-instalar-y-configurar-un-servidor-samba-en-debian">Linuxito - Instalar y configurar un servidor Samba en Debian</a></li>
<li><a href="https://unixcop.com/how-to-configure-samba-server-with-debian-11/">Unixcop - How to configure Samba Server with Debian 11</a></li>
<li><a href="https://www.samba.org/samba/docs/current/man-html/smb.conf.5.html">smb.conf — The configuration file for the Samba suite</a></li>
</ul>Daniel Martín GonzálezDespite having different ways of accessing files on your server, perhaps all of them become somewhat tedious if we are used to browsing through Windows folders. I have recently discovered a very simple way to have a Samba file server in Debian and derivatives to be able to access the files on the server from a Windows client as if it were another folder.Tus archivos desde Windows, instalando un Servidor Samba en Debian2022-01-07T00:00:00+01:002022-01-07T00:00:00+01:00https://www.danielmartingonzalez.com/es/servidor-samba-en-debian<p>Pese a tener diversas formas de <a href="https://www.danielmartingonzalez.com/es/explorador-de-archivos-online-para-tu-servidor/">acceder a los archivos del servidor</a>, quizás todas ellas se hacen algo tediosas si estamos acostumbrados a la navegación por carpetas de <em>Windows</em>. Hace poco he descubierto una manera muy sencilla de disponer <a href="https://www.samba.org/"><strong>un servidor de archivos <em>Samba</em></strong></a> en <a href="https://www.debian.org/index.es.html"><em>Debian</em></a> y derivados para poder acceder desde un cliente <em>Windows</em> como si fuera una carpeta más a los archivos del servidor.</p>
<p>¿Por qué necesitamos un servidor <em>Samba</em> para acceder desde <em>Windows</em> a los archivos en un servidor <em>Linux</em>? Bueno. Por defecto, ambos sistemas utilizan protocolos de archivos compartidos distintos. <em>Samba</em> es una implementación libre del protocolo de archivos compartidos de <em>Microsoft Windows</em> (antiguamente llamado <em>SMB</em>, renombrado recientemente a <em>CIFS</em>) para sistemas de tipo <em>UNIX</em>.</p>
<h2 id="instalación">Instalación</h2>
<blockquote>
<p>La mayoría de los siguientes comandos necesitan privilegios <code class="language-plaintext highlighter-rouge">root</code> para su ejecución. Puedes usar <code class="language-plaintext highlighter-rouge">sudo</code> o iniciar sesión como usuario <code class="language-plaintext highlighter-rouge">root</code> y ahorrarte escribir el prefijo en cada comando.</p>
</blockquote>
<p>Instalamos el paquete <em>Samba server</em>:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>apt update
<span class="nv">$ </span><span class="nb">sudo </span>apt <span class="nb">install </span>samba <span class="nt">-y</span>
</code></pre></div></div>
<p>Habilitamos el servicio <em>Samba</em> para que inicie con el sistema:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>systemctl <span class="nb">enable </span>smbd
</code></pre></div></div>
<p>Si usamos el <em>firewall</em> del sistema, necesitamos abrir los siguientes puertos:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>ufw allow 139
<span class="nv">$ </span><span class="nb">sudo </span>ufw allow 445
</code></pre></div></div>
<p>Reiniciamos el servicio <code class="language-plaintext highlighter-rouge">smbd</code> y comprobamos que está ejecutándose:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>systemctl restart smbd
<span class="nv">$ </span><span class="nb">sudo </span>systemctl status smbd
? smbd.service - Samba SMB Daemon
...
Status: <span class="s2">"smbd: ready to serve connections..."</span>
...
</code></pre></div></div>
<h2 id="configurando-samba-share">Configurando Samba Share</h2>
<p>Edita el archivo <code class="language-plaintext highlighter-rouge">smb.conf</code> con el comando <code class="language-plaintext highlighter-rouge">sudo nano /etc/samba/smb.conf</code>, añadiendo al final del documento lo siguiente:</p>
<div class="language-config highlighter-rouge"><div class="highlight"><pre class="highlight"><code>[<span class="n">media</span>]
<span class="n">comment</span> = <span class="n">media</span> <span class="n">folder</span>
<span class="n">path</span> = /<span class="n">media</span>
<span class="n">writeable</span> = <span class="n">yes</span>
<span class="n">browsable</span> = <span class="n">yes</span>
<span class="n">public</span> = <span class="n">no</span>
<span class="n">valid</span> <span class="n">users</span> = <span class="n">danimart1991</span>, <span class="n">root</span>
</code></pre></div></div>
<p>Adjunto una explicación de cada línea:</p>
<ul>
<li><code class="language-plaintext highlighter-rouge">[media]</code>: Es el nombre corto que describe aquello que vamos a compartir. Un identificador.</li>
<li><code class="language-plaintext highlighter-rouge">comment</code>: Un comentario para describir que estamos compartiendo.</li>
<li><code class="language-plaintext highlighter-rouge">path</code>: La ruta de la carpeta que queremos compartir.</li>
<li><code class="language-plaintext highlighter-rouge">writeable</code>: Indica si queremos que la carpeta sea de solo lectura o si quieres permitir que se realizan escrituras y borrados sobre ella.</li>
<li><code class="language-plaintext highlighter-rouge">browsable</code>: Si este recurso compartido se ve en la lista de recursos compartidos disponibles en una vista de red y en la lista de navegación.</li>
<li><code class="language-plaintext highlighter-rouge">public</code>: Indica si la carpeta NO necesita contraseña para acceder a ella.</li>
<li><code class="language-plaintext highlighter-rouge">valid users</code>: Listado de usuarios que tendrán acceso a la carpeta.</li>
</ul>
<blockquote>
<p>Puedes consultar más opciones en la <a href="https://www.samba.org/samba/docs/current/man-html/smb.conf.5.html">documentación del archivo de configuración</a>.</p>
</blockquote>
<p>Guardamos el archivo con la tecla <code class="language-plaintext highlighter-rouge">F3</code> y salimos con <code class="language-plaintext highlighter-rouge">F2</code>.</p>
<h2 id="configurando-usuarios">Configurando Usuarios</h2>
<p>Como has podido ver, he indicado en el campo <code class="language-plaintext highlighter-rouge">valid users</code> que usuarios pueden acceder a los archivos. Estos usuarios han de tener acceso a la carpeta compartida y sus archivos, de lo contrario no podrán verlos cuando accedamos desde <em>Windows</em>.</p>
<p>Además, estos usuarios tienen que estar creados en nuestro servidor. De no ser así, basta con usar el comando:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>useradd danimart1991
</code></pre></div></div>
<p>A continuación. Tenemos que declarar ese usuario en <em>Samba</em> y asignarle una contraseña exclusiva para este servicio. Para ello usamos el siguiente comando:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>smbpasswd <span class="nt">-a</span> danimart1991
New SMB password: xxxxxxxx
Retype new SMB password: xxxxxxxx
</code></pre></div></div>
<p>Finalmente reiniciamos el servicio:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>systemctl restart smbd
</code></pre></div></div>
<h2 id="conclusión">Conclusión</h2>
<p>Ya tenemos configurado nuestro servidor <em>Samba</em> para su acceso desde <em>Windows</em>. Basta con abrir un <em>Explorador de Archivos</em>, escribir la dirección del servidor y acceder indicando las credenciales que hemos creado previamente.</p>
<p><a href="/assets/posts/es/servidor-samba-en-debian/windows-samba.png"><img src="/assets/posts/es/servidor-samba-en-debian/windows-samba.png" alt="Acceso Servidor desde Windows con Samba" /></a></p>
<p>Ahora tendrás un acceso rápido y sencillo desde tus dispositivos <em>Windows</em> a las carpetas del servidor.</p>
<h2 id="referencias">Referencias</h2>
<ul>
<li>Agradecimientos a José Antonio Simancas (<em>JASimancas</em>)</li>
<li><a href="https://www.samba.org/">Samba</a></li>
<li><a href="https://www.server-world.info/en/note?os=Debian_11&p=samba&f=1">Server World - Debian 11 Bullseye : Samba</a></li>
<li><a href="https://www.linuxito.com/gnu-linux/nivel-basico/1233-instalar-y-configurar-un-servidor-samba-en-debian">Linuxito - Instalar y configurar un servidor Samba en Debian</a></li>
<li><a href="https://unixcop.com/how-to-configure-samba-server-with-debian-11/">Unixcop - How to configure Samba Server with Debian 11</a></li>
<li><a href="https://www.samba.org/samba/docs/current/man-html/smb.conf.5.html">smb.conf — The configuration file for the Samba suite</a></li>
</ul>Daniel Martín GonzálezPese a tener diversas formas de acceder a los archivos del servidor, quizás todas ellas se hacen algo tediosas si estamos acostumbrados a la navegación por carpetas de Windows. Hace poco he descubierto una manera muy sencilla de disponer un servidor de archivos Samba en Debian y derivados para poder acceder desde un cliente Windows como si fuera una carpeta más a los archivos del servidor.From Debian 10 to Debian 112022-01-01T00:00:00+01:002022-01-01T00:00:00+01:00https://www.danielmartingonzalez.com/en/from-debian10-to-debian11<p><a href="https://www.debian.org/News/2021/20210814"><em>Debian 11</em> (<em>bullseye</em>)</a> has been available for use on the stable channel for several months now. This release contains a total of 59,551 packages of which more than 11,294 are new, and this despite a significant reduction of more than 9,519 packages that were marked as obsolete and were removed. 42,821 packages have been updated and 5,434 remain unchanged. That is, a large number of improvements and bug fixes that will improve our server.</p>
<p><strong>Today we are going to see how to upgrade our system from <em>Debian 10</em> to <em>Debian 11</em> in a few steps.</strong></p>
<h2 id="current-system-backup">Current system backup</h2>
<p>The first and foremost thing is <strong>to have a backup of the system</strong>. The update should not break anything, but just in case. <a href="https://www.danielmartingonzalez.com/en/backups-towards-docker/">We are going to make a backup with <em>Duplicati</em></a>.</p>
<h2 id="updating-current-packages">Updating current packages</h2>
<p><strong>Update existing <em>Debian 10</em> packages to the latest version</strong> using the following commands:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>apt-get update <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt-get upgrade <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt-get dist-upgrade <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt-get autoremove <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt-get clean <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>reboot
</code></pre></div></div>
<h2 id="modifying-the-repositories">Modifying the repositories</h2>
<p><strong>Modify the list of system repositories</strong> with the command <code class="language-plaintext highlighter-rouge">sudo nano /etc/apt/sources.list</code> replacing those that contain the word <code class="language-plaintext highlighter-rouge">buster</code> with the following:</p>
<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>deb http://deb.debian.org/debian/ bullseye main contrib non-free
deb-src http://deb.debian.org/debian/ bullseye main contrib non-free
deb http://security.debian.org/debian-security bullseye-security main contrib non-free
deb-src http://security.debian.org/debian-security bullseye-security main contrib non-free
deb http://deb.debian.org/debian/ bullseye-updates main
deb-src http://deb.debian.org/debian/ bullseye-updates main
</code></pre></div></div>
<h2 id="optional-update-docker-key">(Optional) Update Docker key</h2>
<p>If we have <em>Docker</em> installed, it is recommended to update the <em>GPG key</em> with the following commands:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>curl <span class="nt">-fsSL</span> https://download.docker.com/linux/debian/gpg | <span class="nb">sudo </span>gpg <span class="nt">--dearmor</span> <span class="nt">-o</span> /usr/share/keyrings/docker-archive-keyring.gpg
<span class="nv">$ </span><span class="nb">sudo echo</span> <span class="s2">"deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian </span><span class="si">$(</span>lsb_release <span class="nt">-cs</span><span class="si">)</span><span class="s2"> stable"</span> | <span class="nb">sudo tee</span> /etc/apt/sources.list.d/docker.list <span class="o">></span> /dev/null
</code></pre></div></div>
<p>If it asks to overwrite, confirm.</p>
<h2 id="upgrading-to-debian-11">Upgrading to Debian 11</h2>
<p>At last, <strong>run the following commands to upgrade your system to <em>Debian 11</em></strong>.</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>apt-get update <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt-get full-upgrade <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>reboot
</code></pre></div></div>
<blockquote>
<p>During installation, keep the local settings in case you ask us to make changes (this is usually the default option).</p>
</blockquote>
<h2 id="updating-and-cleaning-packages">Updating and cleaning packages</h2>
<p>Finally, <strong>update all installed packages</strong> and perform a cleanup of obsolete packages with the following commands:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span>apt-get update <span class="nt">-y</span>
<span class="nv">$ </span>apt-get upgrade <span class="nt">-y</span>
<span class="nv">$ </span>apt-get dist-upgrade <span class="nt">-y</span>
<span class="nv">$ </span>apt-get autoremove <span class="nt">-y</span>
<span class="nv">$ </span>apt-get clean <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>reboot
</code></pre></div></div>
<p>Repeat this list of commands again until the result of each one indicates that no more packages have to be installed, updated and/or deleted.</p>
<h2 id="conclusion">Conclusion</h2>
<p>You can check the version of <em>Debian</em> installed on the system with the command <code class="language-plaintext highlighter-rouge">lsb_release -a</code>.</p>
<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Distributor ID: Debian
Description: Debian GNU/Linux 11 (bullseye)
Release: 11
Codename: bullseye
</code></pre></div></div>
<p>Following the list of commands in this tutorial, our server will be updated to <em>Debian 11</em> and we will have stable support for 5 years. Remember to keep the packages updated to avoid different failures and to have a healthy system.</p>
<h2 id="references">References</h2>
<ul>
<li>Thanks to José Antonio Simancas (<em>JASimancas</em>)</li>
<li><a href="https://www.cyberciti.biz/faq/update-upgrade-debian-10-to-debian-11-bullseye/">Cybercity - How to upgrade Debian 10 to Debian 11 Bullseye using the CLI</a></li>
<li><a href="https://docs.docker.com/engine/install/debian/">Docker Docs - Install Docker Engine on Debian</a></li>
</ul>Daniel Martín GonzálezDebian 11 (bullseye) has been available for use on the stable channel for several months now. This release contains a total of 59,551 packages of which more than 11,294 are new, and this despite a significant reduction of more than 9,519 packages that were marked as obsolete and were removed. 42,821 packages have been updated and 5,434 remain unchanged. That is, a large number of improvements and bug fixes that will improve our server.De Debian 10 a Debian 112022-01-01T00:00:00+01:002022-01-01T00:00:00+01:00https://www.danielmartingonzalez.com/es/de-debian10-a-debian-11<p><a href="https://www.debian.org/News/2021/20210814"><em>Debian 11</em> (<em>bullseye</em>)</a> lleva ya varios meses disponible en el canal estable para su uso. Esta versión contiene un total de 59.551 paquetes de los que más de 11.294 son nuevos, y esto a pesar de una reducción significativa de más de 9.519 paquetes que se marcaron como obsoletos y fueron eliminados. 42.821 paquetes se han actualizado y 5.434 permanecen sin modificar. Es decir, una gran cantidad de mejoras y solución de fallos que mejorarán nuestro servidor.</p>
<p><strong>Hoy vamos a ver como actualizar nuestro sistema de <em>Debian 10</em> a <em>Debian 11</em> en pocos pasos.</strong></p>
<h2 id="copia-de-seguridad-del-sistema-actual">Copia de seguridad del sistema actual</h2>
<p>Lo primero y más importante es <strong>tener una copia de seguridad del sistema</strong>. Con la actualización no se debería romper nada, pero por si acaso. <a href="https://www.danielmartingonzalez.com/es/copias-de-seguridad-para-con-docker/">Vamos a realizar una copia de seguridad con <em>Duplicati</em></a>.</p>
<h2 id="actualizando-los-paquetes-actuales">Actualizando los paquetes actuales</h2>
<p><strong>Actualiza los paquetes existentes en <em>Debian 10</em></strong> para tenerlos a la última versión usando los siguientes comandos:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>apt-get update <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt-get upgrade <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt-get dist-upgrade <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt-get autoremove <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt-get clean <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>reboot
</code></pre></div></div>
<h2 id="modificando-los-repositorios">Modificando los repositorios</h2>
<p><strong>Modifica la lista de repositorios del sistema</strong> con el comando <code class="language-plaintext highlighter-rouge">sudo nano /etc/apt/sources.list</code> sustituyendo los que contengan la palabra <code class="language-plaintext highlighter-rouge">buster</code> por los siguientes:</p>
<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>deb http://deb.debian.org/debian/ bullseye main contrib non-free
deb-src http://deb.debian.org/debian/ bullseye main contrib non-free
deb http://security.debian.org/debian-security bullseye-security main contrib non-free
deb-src http://security.debian.org/debian-security bullseye-security main contrib non-free
deb http://deb.debian.org/debian/ bullseye-updates main
deb-src http://deb.debian.org/debian/ bullseye-updates main
</code></pre></div></div>
<h2 id="opcional-actualizar-key-de-docker">(Opcional) Actualizar key de Docker</h2>
<p>Si tenemos instalado <em>Docker</em>, es recomendable actualizar la <em>GPG key</em> con los siguientes comandos:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>curl <span class="nt">-fsSL</span> https://download.docker.com/linux/debian/gpg | <span class="nb">sudo </span>gpg <span class="nt">--dearmor</span> <span class="nt">-o</span> /usr/share/keyrings/docker-archive-keyring.gpg
<span class="nv">$ </span><span class="nb">sudo echo</span> <span class="s2">"deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian </span><span class="si">$(</span>lsb_release <span class="nt">-cs</span><span class="si">)</span><span class="s2"> stable"</span> | <span class="nb">sudo tee</span> /etc/apt/sources.list.d/docker.list <span class="o">></span> /dev/null
</code></pre></div></div>
<p>Si pide sobrescribir, confirmamos.</p>
<h2 id="actualizando-a-debian-11">Actualizando a Debian 11</h2>
<p>Por fin, <strong>ejecuta los siguientes comandos para actualizar tu sistema a <em>Debian 11</em></strong>.</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span><span class="nb">sudo </span>apt-get update <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>apt-get full-upgrade <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>reboot
</code></pre></div></div>
<blockquote>
<p>Durante la instalación, conservar las configuraciones locales en caso de que nos pida realizar cambios (suele ser la opción por defecto).</p>
</blockquote>
<h2 id="actualizando-y-limpiando-paquetes">Actualizando y limpiando paquetes</h2>
<p>Por último, <strong>actualizamos todos los paquetes instalados</strong> y realizamos una limpieza de paquetes obsoletos con los siguientes comandos:</p>
<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span>apt-get update <span class="nt">-y</span>
<span class="nv">$ </span>apt-get upgrade <span class="nt">-y</span>
<span class="nv">$ </span>apt-get dist-upgrade <span class="nt">-y</span>
<span class="nv">$ </span>apt-get autoremove <span class="nt">-y</span>
<span class="nv">$ </span>apt-get clean <span class="nt">-y</span>
<span class="nv">$ </span><span class="nb">sudo </span>reboot
</code></pre></div></div>
<p>Repetimos esta lista de comandos nuevamente hasta que el resultado de cada uno indique que no se tienen que instalar, actualizar y/o borrar más paquetes.</p>
<h2 id="conclusión">Conclusión</h2>
<p>Podemos comprobar la versión de <em>Debian</em> instalada en el sistema con el comando <code class="language-plaintext highlighter-rouge">lsb_release -a</code>.</p>
<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Distributor ID: Debian
Description: Debian GNU/Linux 11 (bullseye)
Release: 11
Codename: bullseye
</code></pre></div></div>
<p>Siguiendo el listado de comandos de este tutorial nuestro servidor estará actualizado a <em>Debian 11</em> y tendremos soporte para 5 años de manera estable. Recuerda mantener los paquetes actualizados para evitar distintos fallos y tener un sistema sano.</p>
<h2 id="referencias">Referencias</h2>
<ul>
<li>Agradecimientos a José Antonio Simancas (<em>JASimancas</em>)</li>
<li><a href="https://www.cyberciti.biz/faq/update-upgrade-debian-10-to-debian-11-bullseye/">Cybercity - How to upgrade Debian 10 to Debian 11 Bullseye using the CLI</a></li>
<li><a href="https://docs.docker.com/engine/install/debian/">Docker Docs - Install Docker Engine on Debian</a></li>
</ul>Daniel Martín GonzálezDebian 11 (bullseye) lleva ya varios meses disponible en el canal estable para su uso. Esta versión contiene un total de 59.551 paquetes de los que más de 11.294 son nuevos, y esto a pesar de una reducción significativa de más de 9.519 paquetes que se marcaron como obsoletos y fueron eliminados. 42.821 paquetes se han actualizado y 5.434 permanecen sin modificar. Es decir, una gran cantidad de mejoras y solución de fallos que mejorarán nuestro servidor.Backups towards Docker2021-10-01T00:00:00+02:002021-10-01T00:00:00+02:00https://www.danielmartingonzalez.com/en/backups-towards-docker<p><a href="https://www.danielmartingonzalez.com/en/docker-and-portainer-in-debian/">Now that we handle <em>Docker</em> more or less adequately</a>, and that we have instantiated a few services on our server with it, the system begins to fill up with data and configurations. As we have seen, all this data that we want to persist is linked from the service with our <em>host</em> through <a href="https://docs.docker.com/storage/">the use of volumes or <em>bind mounts</em></a>. Faced with this more or less organized increase, we are faced with the problem of being able to lose all the work done to date if a catastrophe occurs on our server.</p>
<p><strong>Today we are going to see how to be able to store all this data in secondary storage, or even in a cloud service and keep one or more backup copies in order to revive a service in the event of any critical failure.</strong></p>
<h2 id="duplicati">Duplicati</h2>
<p>Among all the services that I have tried to create backup copies, I prefer <a href="https://www.duplicati.com/"><strong><em>Duplicati</em></strong></a> because <strong>it has all the requirements I need and some more</strong>:</p>
<ul>
<li>Supports file and folder encryption using <em>AES-256</em> encryption.</li>
<li>It has both a <em>Web</em> interface and a command line for the total management of the service.</li>
<li>Allows to host backups very simply remotely (this includes protocols such as <em>FTP</em>, <em>WebDAV</em>, <em>SSH</em>,… or clouds such as <em>Microsoft OneDrive</em>, <em>Amazon S3</em>, <em>Google Drive</em>,…).</li>
<li>Incremental backups, with which we can save a huge amount of space by saving only the changes made since the previous load.</li>
<li>Planner to make backup copies when we are interested.</li>
<li>Uses deduplication technology. <em>Duplicati</em> parses the content of files and stores blocks of data. Because of that, <em>Duplicati</em> will find duplicate files and similar content and store them only once in the backup. As <em>Duplicati</em> parses the contents of files, it can handle situations very well if files and folders are moved or renamed. Since the content does not change, the next backup will be small.</li>
<li>Smart backups: Save backups gradually over time, and dispose of old ones. Saving a backup copy of the last 7 days, another copy each of the last 4 weeks and a last copy each of the 12 months. But we can also mark another type of retention if we are more interested in it.</li>
<li>Allows automatic updates. Although in my case, <a href="https://www.danielmartingonzalez.com/en/automatically-update-containers/">I will use <em>Ouroboros</em></a> to keep the <em>Docker</em> container updated in which we are going to instantiate it.</li>
</ul>
<p>On the contrary, it presents a series of drawbacks, which for now have not been “solved”.</p>
<ul>
<li>It does not have a powerful notification system. You can hardly send <em>Emails</em> or <em>HTTP</em> messages to events that happens when making backups.</li>
<li>If we lose the encryption key, all the backup copies that use this key will be useless.</li>
<li>If for any reason the <em>Duplicati</em> database becomes corrupted, it is very possible that the backup copies will be unusable in that instance. To fix this, you would have to reinstall <em>Duplicati</em> with a fresh installation and restore a backup of your configuration.</li>
<li>Backup copies can only be managed, made or restored with <em>Duplicati</em>. It uses its own backup system and cannot be opened with another application or file manager.</li>
</ul>
<h2 id="preparation">Preparation</h2>
<p>When making backup copies, <strong>not all data should be preserved</strong>. It is something that must be thought through carefully and analyzed in the context of each service. For example, I am a bit reluctant to save logs (<em>logs</em>), since personally, it is not something that I am interested in keeping. But it can still be important for another person to, for example, detect possible errors or improvements.</p>
<p>Although <em>Duplicati</em> allows a great variety of filters, selection of folders or even ignoring files and folders, in my opinion, <strong>the ideal thing is to have the information of the <em>Docker</em> containers divided into two or three folders according to the criticality of your data</strong>. This means that I do not have to modify the configuration of the backup copies in <em>Duplicati</em> if I add or remove a container and, in this way, I have the information located due to its criticality. So, for example, we can organize folders in this way:</p>
<div class="language-yaml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="s">/</span>
<span class="s">├ docker</span>
<span class="s">│ ├ etc</span> <span class="c1"># Folder where I keep the important volumes that I want to keep</span>
<span class="s">│ │ ├ container1_config</span>
<span class="s">│ │ ├ container1_data</span>
<span class="s">│ │ ├ container2_config</span>
<span class="s">│ │ └ ...</span>
<span class="s">│ └ tmp</span> <span class="c1"># Folder where I save the volumes with logs or temporary files</span>
<span class="s">│ ├ container1_log</span>
<span class="s">│ ├ container2_log</span>
<span class="s">│ ├ container2_cache</span>
<span class="s">│ └ ...</span>
<span class="s">└ ...</span>
</code></pre></div></div>
<p>This is just an option, but you can order the volume folders as you are most interested or use the filters that <em>Duplicati</em> brings if it is more useful for your system.</p>
<p>The services themselves, many times, allow you to configure the folders where your data is stored and thus be able to separate what we want to save from what is not important. After the service is configured, it is necessary to reconfigure the associated volumes.</p>
<h2 id="installation">Installation</h2>
<p>As on other occasions, <strong>we are going to instantiate the service using <em>Docker</em></strong>. The <a href="https://hub.docker.com/r/duplicati/duplicati"><em>Duplicati</em> container</a> gives us does not have much complexity, we just have to execute the following command in our terminal changing a couple of parameters.</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span>docker run <span class="nt">-d</span> <span class="nt">--name</span><span class="o">=</span>duplicati <span class="nt">--hostname</span><span class="o">=</span>duplicati <span class="nt">-e</span> <span class="nv">TZ</span><span class="o">=</span>Europe/Madrid <span class="nt">--net</span><span class="o">=</span>bridge <span class="nt">-p</span> 8200:8200 <span class="nt">-v</span> /docker/etc/duplicati_data:/data <span class="nt">-v</span> /docker/backups:/backups <span class="nt">-v</span> /docker/etc:/source <span class="nt">--restart</span> always duplicati/duplicati
</code></pre></div></div>
<blockquote>
<p>You also have an example for <em>Docker Compose</em> <a href="https://github.com/danimart1991/docker-compose-files/tree/master/duplicati">here</a>.</p>
</blockquote>
<p>As you can see, I’m going to use the host folder <code class="language-plaintext highlighter-rouge">/docker/backups</code> folder to save the local backups and the folder <code class="language-plaintext highlighter-rouge">/docker/etc</code> as a data source for backups. As is common in <em>Docker</em>, you can link all the folders that you think are appropriate with the container to make the backups as you like.</p>
<blockquote>
<p>Note: You can also see how I include the <em>Duplicati</em> configuration folder among the files that I am going to save by putting it inside the data source folder with <code class="language-plaintext highlighter-rouge">-v /docker/etc/duplicati_data:/data</code>.</p>
</blockquote>
<p>Once the <em>Duplicati</em> service is instantiated. You can access its Web manager from <code class="language-plaintext highlighter-rouge">http://IPDETUSERVIDOR:8200</code>.</p>
<h2 id="setting-up-backups">Setting up backups</h2>
<p>Once the preparations have been made and <em>Duplicati</em> has been installed, <strong>we can now create our automated backup system</strong>.</p>
<p>Once inside the <em>Duplicati</em> management page, we click on <em>“Add backup”</em> and <em>“Configure new backup”</em>.</p>
<p><a href="/assets/posts/en/backups-towards-docker/new-backup.png"><img src="/assets/posts/en/backups-towards-docker/new-backup.png" alt="Configure new backup" /></a></p>
<p>In the first step, we indicate a name and description that are reasonable and activate <em>AES-256</em> encryption, this will protect the copied data. Generate or write a security phrase and write it down in a secret place, <strong>IT IS VERY IMPORTANT</strong>.</p>
<p><a href="/assets/posts/en/backups-towards-docker/general-backup-settings.png"><img src="/assets/posts/en/backups-towards-docker/general-backup-settings.png" alt="General Backup Settings" /></a></p>
<p>In the second step, we mark what we want to be the destination of the backup. In this example, we want the copies to end up in a personal cloud with <em>Microsoft OneDrive</em>, for this we will only have to log in to the service and indicate a destination folder.</p>
<p><a href="/assets/posts/en/backups-towards-docker/destination-backup-settings.png"><img src="/assets/posts/en/backups-towards-docker/destination-backup-settings.png" alt="Destination Backup Settings" /></a></p>
<p>In the third step, we will configure the source data, we will do it by linking the host folder where we save the data on which we want to make backup copies with the <code class="language-plaintext highlighter-rouge">source</code> folder inside the <em>Duplicati</em> container, we select that folder as the source. Inside, we can see the folders on which the copy will be made.</p>
<p>We can make other configurations if desired, and even apply filters or exclusions.</p>
<p><a href="/assets/posts/en/backups-towards-docker/source-backup-settings.png"><img src="/assets/posts/en/backups-towards-docker/source-backup-settings.png" alt="Source Backup Settings" /></a></p>
<p>In the fourth step we are going to configure a schedule in which to perform backups. In this case, I want the copy to run every day at 05:00.</p>
<p><a href="/assets/posts/en/backups-towards-docker/schedule-backup-settings.png"><img src="/assets/posts/en/backups-towards-docker/schedule-backup-settings.png" alt="Schedule Backup Settings" /></a></p>
<p>In the fifth step, other options are decided, such as the size of the volumes (blocks into which the backup will be divided), or what type of preservation is desired, with a retention of copies being recommended (although not required). intelligent. This configuration, like the others, will depend on the type of backup we want and the capacity of the destination.</p>
<p><a href="/assets/posts/en/backups-towards-docker/other-backup-settings.png"><img src="/assets/posts/en/backups-towards-docker/other-backup-settings.png" alt="Other Backup Settings" /></a></p>
<p>Once the configuration is saved, we can make a first backup to verify that everything works correctly.</p>
<p>From the home screen, we will have all the information about the number of copies made, space occupied by them, upcoming executions, etc.</p>
<p><a href="/assets/posts/en/backups-towards-docker/backup-details.png"><img src="/assets/posts/en/backups-towards-docker/backup-details.png" alt="Backup Details" /></a></p>
<h2 id="restore-backups">Restore Backups</h2>
<p>Let’s imagine for a moment, that a catastrophe has occurred and we want to recover data from a backup copy. <strong><em>Duplicati</em> allows us to restore backup copies incrementally if this has been configured and restore parts of that copy as files or folders separately</strong>.</p>
<p>If the catastrophe is not so serious as to have destroyed <em>Duplicati</em> and its configuration, simply enter the <em>Duplicati Web</em> manager, click on the <em>“Restore”</em> menu, and select the configuration from which you want to recover (<em>Docker Services</em> in this article). Then, we select the data to recover and finally what we want to do with that data. For example, we can recover a file for a change that has broken a configuration of a service, to a previous version of it.</p>
<p><a href="/assets/posts/en/backups-towards-docker/restore-backup-settings.png"><img src="/assets/posts/en/backups-towards-docker/restore-backup-settings.png" alt="Backup Restore Settings" /></a></p>
<p><a href="/assets/posts/en/backups-towards-docker/restore-options.png"><img src="/assets/posts/en/backups-towards-docker/restore-options.png" alt="Backup Restore Options" /></a></p>
<p>But, it can also happen that the catastrophe is total and the configuration of the server or <em>Duplicati</em> has been unusable. In order to restore a more “serious” copy from a site that we have not previously configured in <em>Duplicati</em> as it is a new installation, we can select <em>“Restore directly from backup files…“</em>, tell it that the copy is hosted, for example, in a cloud and from there, restore the data in the same way that I have commented in the previous paragraph.</p>
<p><a href="/assets/posts/en/backups-towards-docker/restore-remote.png"><img src="/assets/posts/en/backups-towards-docker/restore-remote.png" alt="Backup Restore Remote" /></a></p>
<p>With this thought in mind, we can make a backup copy of the <em>Duplicati</em> configuration and database, so if something serious happens, we can restore it later.</p>
<h2 id="conclusion">Conclusion</h2>
<p>With what has been seen in this post, <strong>we should have several backup copies in an external storage or cloud</strong> that ensures certain recovery from disasters and small configuration changes that break the system or the services instantiated in <em>Docker</em> containers.</p>
<p>From here, and depending on your configuration in <em>Duplicati</em>, you will not have to touch the service much more. If you are installing new containers, you only have to take into account the directories where you create the volumes associated with them to create backup copies of the data that you really want to keep.</p>
<p>Feel free to ask or contribute your experience by following this article in the comments.</p>
<p>This and other articles complement the documentation of my <a href="https://github.com/danimart1991"><strong><em>GitHub</em> repositories</strong></a> where all the configuration of my server and the home automation associated with my house are available.</p>
<h2 id="see-also">See also</h2>
<ul>
<li><a href="https://www.duplicati.com/articles/">Duplicati - Articles</a></li>
<li><a href="https://duplicati.readthedocs.io/en/latest/">Duplicati - Documentation</a></li>
<li><a href="https://hub.docker.com/r/duplicati/duplicati">DockerHub - Duplicati Docker Documentation</a></li>
</ul>Daniel Martín GonzálezNow that we handle Docker more or less adequately, and that we have instantiated a few services on our server with it, the system begins to fill up with data and configurations. As we have seen, all this data that we want to persist is linked from the service with our host through the use of volumes or bind mounts. Faced with this more or less organized increase, we are faced with the problem of being able to lose all the work done to date if a catastrophe occurs on our server.Copias de Seguridad para con Docker2021-09-30T00:00:00+02:002021-09-30T00:00:00+02:00https://www.danielmartingonzalez.com/es/copias-de-seguridad-para-con-docker<p><a href="https://www.danielmartingonzalez.com/es/docker-y-portainer-en-debian/">Ahora que manejamos más o menos adecuadamente <em>Docker</em></a>, y que hemos instanciado unos cuantos servicios en nuestro servidor con él, el sistema empieza a llenarse de datos y configuraciones. Tal y como hemos ido viendo, todos estos datos que queremos persistir se vinculan desde el servicio con nuestro <em>host</em> mediante <a href="https://docs.docker.com/storage/">el uso de volúmenes o <em>bind mounts</em></a>. Ante este aumento mas o menos organizado, se nos plantea el problema de poder perder todo el trabajo realizado hasta la fecha si ocurre una catástrofe en nuestro servidor.</p>
<p><strong>Hoy vamos a ver la forma de poder almacenar todos estos datos en un almacenamiento secundario, o incluso en un servicio en la nube y conservar una o varias copias de seguridad para así poder revivir un servicio ante cualquier fallo crítico.</strong></p>
<h2 id="duplicati">Duplicati</h2>
<p>Entre todos los servicios que he probado para crear las copias de seguridad, me quedo con <a href="https://www.duplicati.com/"><strong><em>Duplicati</em></strong></a> porque <strong>dispone de todos los requisitos que necesito y alguno más</strong>:</p>
<ul>
<li>Soporta encriptación de archivos y carpetas mediante cifrado <em>AES-256</em>.</li>
<li>Dispone tanto de interfaz <em>Web</em> como línea de comandos para la gestión total del servicio.</li>
<li>Permite alojar las copias de seguridad de manera muy simple en remoto (esto incluye protocolos como <em>FTP</em>, <em>WebDAV</em>, <em>SSH</em>… o nubes como <em>Microsoft OneDrive</em>, <em>Amazon S3</em>, <em>Google Drive</em>, etc.).</li>
<li>Copias de seguridad incrementales, con lo que conseguimos ahorrar una cantidad enorme de espacio guardando solo los cambios realizados desde la carga anterior.</li>
<li>Planificador para realizar las copias de seguridad cuando nos interese.</li>
<li>Utiliza la tecnología de deduplicación. <em>Duplicati</em> analiza el contenido de los archivos y almacena bloques de datos. Debido a eso, <em>Duplicati</em> encontrará archivos duplicados y contenido similar y los almacenará solo una vez en la copia de seguridad. Como <em>Duplicati</em> analiza el contenido de los archivos, puede manejar situaciones muy bien si los archivos y carpetas se mueven o se les cambia el nombre. Como el contenido no cambia, la próxima copia de seguridad será pequeña.</li>
<li>Copias de seguridad inteligentes: Guarda copias de seguridad gradualmente en el tiempo, y desecha las antiguas. Guardando una copia de seguridad de los últimos 7 días, otra copia cada una de las últimas 4 semanas y una última copia cada uno de los 12 meses. Pero también podemos marcar otro tipo de retención si nos interesa más.</li>
<li>Permite actualizaciones automáticas. Aunque en mi caso, <a href="https://www.danielmartingonzalez.com/es/actualizacion-automatica-de-contenedores/">usaré <em>Ouroboros</em></a> para mantener actualizado el contenedor <em>Docker</em> en el que vamos a instanciarlo.</li>
</ul>
<p>Por contra, presenta una serie de inconvenientes, que por ahora no han sido “solucionados”.</p>
<ul>
<li>No posee un sistema de notificaciones potente. Apenas se pueden mandar <em>Emails</em> o mensajes <em>HTTP</em> ante eventos que ocurran al realizar las copias de seguridad.</li>
<li>Si perdemos la clave de cifrado, todas las copias de seguridad que usen esta clave quedarán inservibles.</li>
<li>Si por cualquier motivo la base de datos de <em>Duplicati</em> se corrompe, es muy posible que las copias de seguridad queden inservibles en esa instancia. Para solucionarlo, habría que reinstanciar <em>Duplicati</em> con una instalación nueva y restaurar una copia de seguridad de su configuración.</li>
<li>Las copias de seguridad solo pueden ser gestionadas, realizadas o restauradas con <em>Duplicati</em>. Usa un sistema de copias de seguridad propio y no pueden ser abiertos con otra aplicación o gestor de archivos.</li>
</ul>
<h2 id="preparación">Preparación</h2>
<p>A la hora de hacer copias de seguridad, <strong>no todos los datos deben o no queremos que sean conservados</strong>. Es algo que se debe pensar detenidamente y analizar con el contexto de cada servicio. Por ejemplo, yo soy un poco reacio a guardar los registros (<em>logs</em>), ya que personalmente, no es algo que para mí tenga interés conservar. Pero igual puede ser importante para otra persona para, por ejemplo, detectar posibles errores o mejoras.</p>
<p>Aunque <em>Duplicati</em> permite una gran variedad de filtros, selección de carpetas o incluso ignorar archivos y carpetas, a mi parecer, <strong>lo ideal es tener dividida la información de los contenedores <em>Docker</em> en dos o tres carpetas según la criticidad de sus datos</strong>. Eso hace que no tenga que modificar la configuración de las copias de seguridad en <em>Duplicati</em> si añado o quito un contenedor y, de esta manera tengo localizada la información por su criticidad. Así, por ejemplo, podemos organizar las carpetas de esta forma:</p>
<div class="language-yaml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="s">/</span>
<span class="s">├ docker</span>
<span class="s">│ ├ etc</span> <span class="c1"># Carpeta donde guardo los volúmenes importantes que quiero conservar</span>
<span class="s">│ │ ├ contenedor1_config</span>
<span class="s">│ │ ├ contenedor1_data</span>
<span class="s">│ │ ├ contenedor2_config</span>
<span class="s">│ │ └ ...</span>
<span class="s">│ └ tmp</span> <span class="c1"># Carpeta donde guardo los volúmenes con logs o archivos temporales</span>
<span class="s">│ ├ contenedor1_log</span>
<span class="s">│ ├ contenedor2_log</span>
<span class="s">│ ├ contenedor2_cache</span>
<span class="s">│ └ ...</span>
<span class="s">└ ...</span>
</code></pre></div></div>
<p>Esto no es más que una opción, pero puedes ordenar las carpetas de volúmenes como más te interese o usar los filtros que trae <em>Duplicati</em> si te es más útil para tu sistema.</p>
<p>Los propios servicios, muchas veces, permiten configurar las carpetas donde se guardan sus datos y así poder separar lo que queremos guardar de lo que no es importante. Una vez configurado el servicio, es necesario reconfigurar los volúmenes asociados.</p>
<h2 id="instalación">Instalación</h2>
<p>Como en otras ocasiones, <strong>vamos a instanciar el servicio usando <em>Docker</em></strong>. El <a href="https://hub.docker.com/r/duplicati/duplicati">contenedor de <em>Duplicati</em></a> no tiene mucha complejidad, solo debemos ejecutar el siguiente comando en nuestro terminal cambiando un par de parámetros.</p>
<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span>docker run <span class="nt">-d</span> <span class="nt">--name</span><span class="o">=</span>duplicati <span class="nt">--hostname</span><span class="o">=</span>duplicati <span class="nt">-e</span> <span class="nv">TZ</span><span class="o">=</span>Europe/Madrid <span class="nt">--net</span><span class="o">=</span>bridge <span class="nt">-p</span> 8200:8200 <span class="nt">-v</span> /docker/etc/duplicati_data:/data <span class="nt">-v</span> /docker/backups:/backups <span class="nt">-v</span> /docker/etc:/source <span class="nt">--restart</span> always duplicati/duplicati
</code></pre></div></div>
<blockquote>
<p>También dispones de un ejemplo para <em>Docker Compose</em> <a href="https://github.com/danimart1991/docker-compose-files/tree/master/duplicati">aquí</a>.</p>
</blockquote>
<p>Como puedes ver, voy a utilizar la carpeta <code class="language-plaintext highlighter-rouge">/docker/backups</code> del <em>host</em> para guardar las copias de seguridad locales y la carpeta <code class="language-plaintext highlighter-rouge">/docker/etc</code> como origen de datos para realizar las copias de seguridad. Como es común en <em>Docker</em>, puedes vincular todas las carpetas que creas apropiadas con el contenedor para realizar las copias de seguridad a tu gusto.</p>
<blockquote>
<p>Nota: También puedes observar como incluyo la propia carpeta de configuración de <em>Duplicati</em> entre los archivos que voy a guardar metiéndola dentro de la carpeta de origen de datos con <code class="language-plaintext highlighter-rouge">-v /docker/etc/duplicati_data:/data</code>.</p>
</blockquote>
<p>Una vez instanciado el servicio de <em>Duplicati</em>. Puedes acceder a su gestor <em>Web</em> desde <code class="language-plaintext highlighter-rouge">http://IPDETUSERVIDOR:8200</code>.</p>
<h2 id="configurando-copias-de-seguridad">Configurando Copias de Seguridad</h2>
<p>Realizados los preparativos e instalado <em>Duplicati</em>, <strong>ya podemos crear nuestro sistema de copias de seguridad automatizadas</strong>.</p>
<p>Una vez dentro de la página de gestión de <em>Duplicati</em>, hacemos click en <em>“Añadir copia de seguridad”</em> y <em>“Configurar nueva copia de seguridad”</em>.</p>
<p><a href="/assets/posts/es/copias-de-seguridad-para-con-docker/nueva-copia-seguridad.png"><img src="/assets/posts/es/copias-de-seguridad-para-con-docker/nueva-copia-seguridad.png" alt="Configurar nueva copia de seguridad" /></a></p>
<p>En el primer paso, indicamos un nombre y descripción que sean razonables y activa el cifrado <em>AES-256</em>, esto protegerá los datos copiados. Genera o escribe una frase de seguridad y apúntala en un lugar secreto, <strong>ES MUY IMPORTANTE</strong>.</p>
<p><a href="/assets/posts/es/copias-de-seguridad-para-con-docker/configuracion-general-copia-seguridad.png"><img src="/assets/posts/es/copias-de-seguridad-para-con-docker/configuracion-general-copia-seguridad.png" alt="Configuración general copia de seguridad" /></a></p>
<p>En el segundo paso, marcamos cual queremos sea el destino de la copia de seguridad. En este ejemplo, queremos que las copias acaben en una nube personal con <em>Microsoft OneDrive</em>, para ello solo tendremos que iniciar sesión en el servicio e indicar una carpeta de destino.</p>
<p><a href="/assets/posts/es/copias-de-seguridad-para-con-docker/configuracion-destino-copia-seguridad.png"><img src="/assets/posts/es/copias-de-seguridad-para-con-docker/configuracion-destino-copia-seguridad.png" alt="Configuración destino copia de seguridad" /></a></p>
<p>En el tercer paso, configuraremos los datos de origen, lo haremos al vincular la carpeta del <em>host</em> donde guardamos los datos sobre los que queremos realizar copias de seguridad con la carpeta <code class="language-plaintext highlighter-rouge">source</code> dentro del contenedor de <em>Duplicati</em>, seleccionamos esa carpeta como origen. En su interior, podremos ver las carpetas sobre las que se hará la copia.</p>
<p>Podemos realizar otras configuraciones si así se desea, e incluso aplicar filtros o exclusiones.</p>
<p><a href="/assets/posts/es/copias-de-seguridad-para-con-docker/configuracion-origen-copia-seguridad.png"><img src="/assets/posts/es/copias-de-seguridad-para-con-docker/configuracion-origen-copia-seguridad.png" alt="Configuración origen copia de seguridad" /></a></p>
<p>En el cuarto paso vamos a configurar un horario en el que realizar las copias de seguridad. En este caso, quiero que la copia se ejecute todos los días a las 05:00.</p>
<p><a href="/assets/posts/es/copias-de-seguridad-para-con-docker/configuracion-horario-copia-seguridad.png"><img src="/assets/posts/es/copias-de-seguridad-para-con-docker/configuracion-horario-copia-seguridad.png" alt="Configuración horario copia de seguridad" /></a></p>
<p>En el quinto paso, se deciden otras opciones como puede ser el tamaño de los volúmenes (bloques en los que se dividirá la copia de seguridad), o qué tipo de conservación se desea, siendo lo recomendable (aunque no obligado) una retención de copias inteligente. Esta configuración como las otras dependerá del tipo de copia de seguridad que deseemos y de la capacidad del destino.</p>
<p><a href="/assets/posts/es/copias-de-seguridad-para-con-docker/configuracion-otros-copia-seguridad.png"><img src="/assets/posts/es/copias-de-seguridad-para-con-docker/configuracion-otros-copia-seguridad.png" alt="Otras opciones copia de seguridad" /></a></p>
<p>Una vez guardada la configuración, podemos realizar una primera copia de seguridad para comprobar que todo funciona correctamente.</p>
<p>Desde la pantalla inicio, dispondremos de toda la información sobre el número de copias realizadas, espacio ocupado por las mismas, próximas ejecuciones, etc.</p>
<p><a href="/assets/posts/es/copias-de-seguridad-para-con-docker/detalle-copia-seguridad.png"><img src="/assets/posts/es/copias-de-seguridad-para-con-docker/detalle-copia-seguridad.png" alt="Detalle copia de seguridad" /></a></p>
<h2 id="restaurar-copias-de-seguridad">Restaurar Copias de Seguridad</h2>
<p>Imaginemos por un momento, que ha ocurrido una catástrofe y queremos recuperar datos de una copia de seguridad. <strong><em>Duplicati</em> nos permite restaurar copias de seguridad de manera incremental si así se ha configurado y restaurar partes de esa copia como archivos o carpetas por separado</strong>.</p>
<p>Si la catástrofe no es tan grave como para haber destruido <em>Duplicati</em> y su configuración, basta con entrar en el gestor <em>Web</em> de <em>Duplicati</em>, hacer click en el menú <em>“Restaurar”</em>, y seleccionar la configuración desde la que se quiere recuperar (<em>Docker Services</em> en este artículo). Luego, seleccionamos los datos a recuperar y por último que se desea hacer con esos datos. Por ejemplo, podemos recuperar un archivo por un cambio que ha roto una configuración de algún servicio, a una versión anterior del mismo.</p>
<p><a href="/assets/posts/es/copias-de-seguridad-para-con-docker/restaurar-configuración-copia-seguridad.png"><img src="/assets/posts/es/copias-de-seguridad-para-con-docker/restaurar-configuración-copia-seguridad.png" alt="Restaurar configuración copia de seguridad" /></a></p>
<p><a href="/assets/posts/es/copias-de-seguridad-para-con-docker/opciones-restauracion.png"><img src="/assets/posts/es/copias-de-seguridad-para-con-docker/opciones-restauracion.png" alt="Opciones restauración copia de seguridad" /></a></p>
<p>Pero, también puede ocurrir que la catástrofe sea total y la configuración del servidor o de <em>Duplicati</em> haya quedado inservible. Para poder restaurar una copia más “seria” desde un sitio que no hemos configurado previamente en <em>Duplicati</em> al ser una instalación nueva, podremos seleccionar <em>“Restaurar directamente desde ficheros de copia de seguridad…“</em>, decirle que la copia está alojada por ejemplo en una nube y desde ahí, restaurar los datos de la misma forma que he comentado en el párrafo anterior.</p>
<p><a href="/assets/posts/es/copias-de-seguridad-para-con-docker/restauracion-remoto.png"><img src="/assets/posts/es/copias-de-seguridad-para-con-docker/restauracion-remoto.png" alt="Restauración remota copia de seguridad" /></a></p>
<p>Con este pensamiento en mente, podemos realizar una copia de seguridad de la configuración y base de datos de <em>Duplicati</em>, para si ocurre algo grave, poder restaurarlo a posteriori.</p>
<h2 id="conclusión">Conclusión</h2>
<p>Con lo visto en este post, <strong>deberíamos disponer de varias copias de seguridad en un almacenamiento externo o nube</strong> que nos asegure cierta recuperación ante desastres y pequeños cambios de configuración que rompan el sistema o los servicios instanciados en contenedores <em>Docker</em>.</p>
<p>A partir de aquí, y dependiendo de tu configuración en <em>Duplicati</em>, <strong>no tendrás que tocar mucho más el servicio</strong>. Si instancias nuevos contenedores, solo has de tener en cuenta los directorios donde creas los volúmenes asociados a los mismos para crear copias de seguridad de los datos que verdaderamente te interesa conservar.</p>
<p>No dudes en preguntar o aportar tu experiencia siguiendo este artículo en los comentarios.</p>
<p>Este y otros artículos complementan la documentación de mis <a href="https://github.com/danimart1991"><strong>repositorios de <em>GitHub</em></strong></a> donde se encuentra disponible toda la configuración de mi servidor y la domótica asociada a mi casa.</p>
<h2 id="ver-también">Ver también</h2>
<ul>
<li><a href="https://www.duplicati.com/articles/">Duplicati - Articles</a></li>
<li><a href="https://duplicati.readthedocs.io/en/latest/">Duplicati - Documentation</a></li>
<li><a href="https://hub.docker.com/r/duplicati/duplicati">DockerHub - Duplicati Docker Documentation</a></li>
</ul>Daniel Martín GonzálezAhora que manejamos más o menos adecuadamente Docker, y que hemos instanciado unos cuantos servicios en nuestro servidor con él, el sistema empieza a llenarse de datos y configuraciones. Tal y como hemos ido viendo, todos estos datos que queremos persistir se vinculan desde el servicio con nuestro host mediante el uso de volúmenes o bind mounts. Ante este aumento mas o menos organizado, se nos plantea el problema de poder perder todo el trabajo realizado hasta la fecha si ocurre una catástrofe en nuestro servidor.