DEV Community: Julián Mulet

ZSH, tu shell DevOps en Ubuntu y Windows Subsystem for Linux

Julián Mulet — Thu, 18 May 2023 05:58:08 +0000

^{Basado en este articulo: Fuente DRA.}

Introducción

El software libre hace tiempo que se ha convertido en la mejor opción para crear servicios y aplicaciones.

Este es el motivo por el cual muchos utilizamos la consola de Linux.

Si además tienes el perfil DevOps, usarás tanto herramientas de desarrollador: git, npm, pip, etc. como otras más propias de sysadmin: docker, kubectl, systemctl, ssh, etc.

Las CLI más habituales

^{NOTA: No pretendo que esta sea una lista cerrada que cubra todos los casos pero son algunas de las más habituales hoy en día.}

git: control de versiones.
npm: gestor de paquetes Node.js.
yarn: gestor de paquetes Node.js alternativo muy popular.
nvm: gestor de entornos virtuales de Node.js.
pip: gestor de paquetes de Python.
docker: gestor de contenedores e imágenes.
docker-compose: gestor de manifiestos de Docker.
kubectl: consola de Kubernetes.
helm: gestor de despliegue de aplicaciones de Kubernetes.

ZSH, tu asistente personal

Manejar todo esto es complejo y aquí es donde entra zsh, un shell personalizable con infinidad de plugins.

Esta es una receta que se puede adaptar fácilmente a las necesidades de cada uno y al final del post encontrarás los links para que puedas explorar esta posibilidad.

Ayudas visuales

Carpeta actual y estado del repositorio git:
Tiempo y estado de ejecución del comando anterior:
Colores que mejoran la legibilidad:

Otras ayudas

Autocompletado de comandos:
Copiar contenido de un fichero al portapapeles:
Comandos recursivos utilizando el doble operador **:
Búsqueda dentro del historial de comandos introduciendo los primeros caracteres y usando los cursores ↑ ↓ →

Instalación

Lo primero que haremos es instalar en el sistema la fuente Nerd Font FiraCode por ser compatible con vscode, related issue:

git clone --depth 1 https://github.com/ryanoasis/nerd-fonts.git /tmp/nerd-fonts

sólo para Windows: Pincha para ver.

Seguimos con la instalación de la fuente, abre la consola Powershell como administrador e introduce estos comandos:

# excluir la seguridad de WSL Ubuntu
wsl -l -v
powershell -ExecutionPolicy Bypass -File .\excludeWSL.ps1
powershell -ExecutionPolicy Bypass -File \tmp\nerd-fonts\install.ps1 FiraCode
Set-ExecutionPolicy Default
Remove-Item -Recurse -Force -Path \tmp\nerd-fonts\

Ahora instala el soporte para las notificaciones:

Install-Module -Name BurntToast

sólo para Linux: Pincha para ver.

Seguimos con la instalación de la fuente, abre la consola e introduce este comando:

/tmp/nerd-fonts/install.sh FiraCode

Ahora instala el soporte para copiar al portapapeles desde el cli:

sudo apt install --no-install-recommends xclip

Y continuamos con el terminal kitty:

sudo apt install kitty

Ábrelo y pulsa ctrl+shift+f2 para generar el fichero de configuración y por último cambia el tema de color con este comando:

bash -c "$(wget -qO- https://raw.githubusercontent.com/Mayccoll/Gogh/master/themes/symphonic.sh)"

Instalar dependencias

sudo apt update
sudo apt upgrade
sudo apt install python-is-python3
sudo apt install python3-pip
sudo apt install powerline
sudo apt install zsh
sudo apt install zplug
sudo apt install fzf
sudo apt install imagemagick
sudo apt install grc
sudo apt install bat
sudo snap install lsd
sudo -H pip3 install Pygments
[ `echo $0` != `which zsh` ] && chsh -s `which zsh`

notify-send

https://codelearn.me/2019/01/13/wsl-windows-toast.html

Mi repo dotfiles:

uxtechie / dotfiles

~/.dotfiles

Recursos de personalización

Aquí encontrarás información para personalizar tu shell.

Más fuentes Nerd Fonts

Iconos de la fuente Nerd Font

Terminal kitty

Temas de color para el terminal

Añade color a comandos genéricos con grc

Sustituto de ls lsd

Sustituto de cat bat

Sustituto de top Bpytop, para cambiar el tema de color pulsa shift+m y elige flat-remix.

Scalable architectures / Project management, tip 1: use NX as monorepo manager

Julián Mulet — Thu, 05 Jan 2023 18:51:49 +0000

Cover attribution: Leeloo Thefirst

Generating and keeping the scaffolding of a Web application updated is one of the most complex tasks I have ever faced managing a project.

I won't go into the details of why I ended up choosing NX over Lerna, Turborepo and even Bit for this task. Here I should clarify that the case of Bit is somewhat different because it manages each component as a separate library.

Why NX?

I will simply show the power of NX with a simple example.

Create a Vite, React, Typescript monorepo quickly:

# NOTE: this gist uses pnpm as Node package manager
# and the next command alias is needed to work as
# expected:
alias pnx="pnpm nx"

# CREATE a new MONOREPO (Typescript, Github CI, pnpm):

# OPTION 1, FRAMEWORK preset type:
npx create-nx-workspace@latest @yourTeamId \
  --ci=github \
  --cli=nx \
  --nxCloud=true \
  --packageManager=pnpm \
  --preset=ts

# OPTION 2, APP preset type:
npx create-nx-workspace@latest @yourTeamId \
  --ci=github \
  --cli=nx \
  --nxCloud=true \
  --packageManager=pnpm \
  --preset=apps

# ---

# ADD a new LIB to previous created monorepo (Vite, 
# SWC, Vitest):
cd @yourTeamId
pnpm install -D @nrwl/js

# OPTION 1, WEB lib:
pnx g @nrwl/js:lib myWebLib \
  --importPath=@yourTeamId/myWebLib \
  --bundler=vite \
  --compiler=swc \
  --unitTestRunner=vitest \
  --publishable \
  --includeBabelRc \
  --tags=type:lib 

# OPTION 2, NODE lib:
pnx g @nrwl/js:lib myLib \
  --importPath=@yourTeamId/myLib \
  --bundler=vite \
  --compiler=swc \
  --unitTestRunner=vitest \
  --publishable \
  --testEnvironment=node \
  --tags=type:lib 

# ---

# ADD a new APP to monorepo (React, Vite, SWC,
# Vitest):
pnpm install -D @nrwl/react
pnx g @nrwl/react:application myApp \
  --importPath=@yourTeamId/myApp \
  --bundler=vite \
  --compiler=swc \
  --unitTestRunner=vitest \
  --routing \
  --tags=type:app

It works as expected? Try it:

# BUILD and run all TESTS
pnx run-many --target=test

# START app in DEV mode
pnx run myApp:serve

And of course this is just a simple example.

With NX you can publish libraries as npm packages, pnx run myLib:publish, and its ease of use invites you to create new libraries more frequently.

This last feature is what really makes your project scalable 😉.

Create your own NX Plugin

It even allows us to create custom plugins to create a scaffolding tailored to your needs:

# ADD a new NX PLUGIN to monorepo (SWC):
pnpm install -D @nrwl/nx-plugin
pnx g @nrwl/nx-plugin:plugin yourPluginName \
  --importPath=@yourTeamId/yourPluginName \
  --compiler=swc \
  --tags=type:plugin

If you give it a chance it is likely to become a rewarding tool in your day to day life.

Thanks for reading me 😄.

Challenge: Why am I using tags when creating libraries and applications?

I look forward to your answer...

Scalable architectures / Code management, tip 1: imperative vs declarative

Julián Mulet — Sat, 17 Dec 2022 19:37:01 +0000

Cover attribution: Namroud Gorguis en Unsplash

Programming techniques and languages have evolved to make reading more intuitive for people, moving from a more #imperative approach, focused on how the task is processed, to a more #declarative one, focused on what is being processed.

This evolution is constantly changing and, therefore, it happens that what 20 years ago was considered declarative today is likely to fall more in the category of imperative.

In this article you can see two examples of this transformation. The first case starts from the #assembly language of a CPU and the second case from the #css markup language.

Evolution of general purpose languages

The for loop

// for-loop.asm

// source:
// https://eclecticlight.co/2021/06/29/code-in-arm-assembly-conditional-loops/
//
// here an imperative example of a classic for-loop
// written in ARM assembler code

// and the maximum index in X4:
MOV X5, #1 // start index = 1
MOV X4, #5 // end index = 5
for_loop:
    // do_something
ADD X5, X5, #1 // increment the index by 1
CMP X5, X4 // check whether end index has been reached
B.LE for_loop // if index <= end index, loop back
// next code after loop

/*
* for-loop.c
*
* here you can show the declarative version of previous 
* assembler example, nowadays this language C implementation
* is an imperative example:
*/
#include <stdio.h>

#define ARRAY_LENGTH(array_var) (sizeof(array_var) / sizeof((array_var)[0]))

void main(void)
{
    int number_collection[] = {1, 2, 3, 4, 5};
    size_t collection_length = ARRAY_LENGTH(number_collection);

    int index;

    for (index=0; index < collection_length; index++) {
        do_something_with_number(number_collection[index]);
    }
};

// for-loop.js

// here a declarative modern functional version of a
// ECMAScript 6 loop

const miscCollection = [1, 2, 3, "hello", "world"];

miscCollection.forEach((itemInCollection) => {
  doSomethingWith(itemInCollection);
});

Evolution of CSS markup language

The abstraction layer

/*
* auto-layout.css
*
* Auto layout, imperative legacy css
*/

.horizontal-center-center {
  display: flex;
  flex-direction: row;
  justify-content: center;
  align-items: center;
}

.horizontal-right-center {
  display: flex;
  flex-direction: row;
  justify-content: flex-end;
  align-items: center;
}

.vertical-bottom-center {
  display: flex;
  flex-direction: column;
  justify-content: flex-end;
  align-items: center;
}

/*
* auto-layout.scss
*
* Auto layout, more declarative version because of
* use of semantic scss mixins
*/

@mixin auto-layout-base {
  display: flex;
}

@mixin auto-layout-horizontal {
  @include auto-layout-base;
  flex-direction: row;
}

@mixin auto-layout-vertical {
  @include auto-layout-base;
  flex-direction: column;
}

.horizontal-center-center {
  @include auto-layout-horizontal;
  justify-content: center;
  align-items: center;
}

.horizontal-right-center {
  @include auto-layout-horizontal;
  justify-content: flex-end;
  align-items: center;
}

.vertical-bottom-center {
  @include auto-layout-vertical;
  justify-content: flex-end;
  align-items: center;
}

/*
* auto-layout.css.ts
*
* full semantic vanilla-extract version
* https://vanilla-extract.style/
*/

import { mixVariants } from "@Utils/styles/mix-variants.css";
import { StyleRule, styleVariants } from "@vanilla-extract/css";

const base: StyleRule = {
  display: "flex",
};

const horizontal: StyleRule = {
  ...base,
  flexDirection: "row",
};

const vertical: StyleRule = {
  ...base,
  flexDirection: "column",
};

const horizontalVariants = styleVariants({
  center: [
    horizontal,
    {
      justifyContent: "center",
    },
  ],
  right: [
    horizontal,
    {
      justifyContent: "flex-end",
    },
  ],
});

const horizontalAlignVariants = styleVariants({
  center: {
    alignItems: "center",
  },
});

const verticalVariants = styleVariants({
  bottom: [
    vertical,
    {
      justifyContent: "flex-end",
    },
  ],
});

const verticalAlignVariants = styleVariants({
  center: {
    alignItems: "center",
  },
});

export const autoLayout = {
  horizontal: {
    center: mixVariants(
      horizontalVariants.center,
      horizontalAlignVariants
    ),
    right: mixVariants(
      horizontalVariants.right,
      horizontalAlignVariants
    ),
  },
  vertical: {
    bottom: mixVariants(
      verticalVariants.bottom,
      verticalAlignVariants
    ),
  },
};

// AutoLayoutDemo.jsx
//
// This auto layout demo show examples of how to
// consume all above different style types
import legacyStyles from "./auto-layout-legacy.css";
import scssStyles from "./auto-layout.scss";
import { autoLayout } from "./auto-layout.css";

export const AutoLayoutDemo = ({ ...other }) => {
  return (
    <article>
      <section class={legacyStyles["horizontal-center-center"]}>
        <p>Horizontal Center Center</p>
      </section>

      <section class={scssStyles["horizontal-right-center"]}>
        <p>Horizontal Right Center</p>
      </section>

      {/* 
        finally, the bellow example use the vanilla-extract
        compiled css resources. Vanilla-extract is not a 
        runtime performance penalty tool like styled-components
        or other similar inline styles tools
       */}
      <section class={autoLayout.vertical.bottom.center}>
        <p>Vertical Bottom Center</p>
      </section>
    </article>
  );
};

Thank you for taking the time to read and share your thoughts.

Julián Mulet

¿Son las configuraciones RAID clásicas compatibles con las unidades SSD?

Julián Mulet — Mon, 04 Oct 2021 12:48:59 +0000

^{Cover image attribution: Dmitry Nosachev, CC BY-SA 4.0, via Wikimedia Commons.}

Introducción

Las unidades de almacenamiento HDD en entornos profesionales son gestionadas en configuraciones RAID por motivos de alta disponibilidad y rendimiento.

¿Sigue siendo válida esta técnica si usamos unidades SSD? Vamos a verlo.

RAID: Redundant Array of Independent Disks

Un sistema RAID forma una matriz distribuyendo los datos entre los distintos discos.

Podemos elegir entre varias configuraciones RAID en cuyos extremos están el RAID 0 y el RAID 1.

El RAID 0 no ofrece protección por lo que estaríamos realmente ante un no RAID.

Funciona sumando la capacidad de los discos y accediendo de forma simultánea a ellos. Obviamente ofrece mayor rendimiento pero la unidad fallará si falla cualquier disco.

¿Y el RAID 1? pues es justo lo contrario, en todos los discos se escribe la misma información y mientras quede un disco operativo la unidad seguirá operativa.

Pero ¿realmente la diferencia en fiabilidad es tan importante? ¿No es el hardware suficientemente fiable? Vamos a verlo en probabilidad de pérdida de datos:

RAID Level	Año 1	Año 2	Año 3
RAID 0	2,8 %	5,7 %	8,4 %
RAID 1	0,00004 %	0,00009 %	0,00013 %

NOTA: estas cifras están extraídas de esta web que usa el modelo MTTDL tomando de referencia discos profesionales de categoria Enterprise.

Como vemos la diferencia entre un RAID 0 y un RAID 1 es inmensa y la probabilidad de fallo de un RAID 0 en el tercer año es de un 8%, cifra inaceptable.

Pero si estamos analizando el entorno profesional ¿Por qué estamos hablando de RAID 0?

Simple: los fabricantes de unidades SSD cada vez que aumentan la capacidad y el rendimiento lo hacen utilizando el concepto de RAID 0, pero... ¿en serio? 😳

Bueno, aunque el concepto es similar hay diferencia.

Los SSD están construidos sumando unidades individuales de memoria flash y, dentro de una misma generación, un disco de 2TB tiene literalmente el doble de unidades que un disco de 1TB a las que la controladora accede de forma simultánea.

Más allá de esta similitud, un disco SSD se fabrica como una única unidad con una vida útil garantizada por el fabricante por lo que podemos estar tranquilos sin preocuparnos por la arquitectura subyacente.

La controladora RAID

Una controladora hardware RAID con discos HDD aporta varias ventajas.

Por un lado, descarga al procesador porque se encarga de la gestión de la matriz RAID sin que tenga que intervenir el sistema operativo y, por otro lado, añade protección contra pérdida de datos porque la caché de escritura está protegida por una batería.

Unidades SSD, algo no encaja

Los bloques de memoria flash de las unidades SSD admiten un número máximo de ciclos de escritura a partir del cual el bloque puede quedar dañado.

Teniendo en cuenta esta limitación, la controladora de la unidad SSD está programada para distribuir estos ciclos de escritura de forma uniforme entre todos los bloques para alargar su vida útil.

Permite incluso redistribuir los datos más mutables moviéndolos frecuentemente a otros bloques por lo que es imposible garantizar la ubicación de un dato dentro de la unidad SSD.

Si la controladora RAID espera que la distribución de los datos sea de forma uniforme, en base al esquema de la matriz RAID, y la controladora de la unidad SSD lo hace de forma aleatoria y ambas lo hacen para alargar su vida útil ¿a quién hacemos caso? sin duda a la controladora SSD.

Cuando se realizan operaciones de borrado el OS informa, enviando comandos TRIM, a la controladora SSD de los bloques que pueden ser borrados y estos se marcan como libres dejándolos de indexar temporalmente. El problema es que la controladora RAID impide que estos comandos lleguen a la unidad SSD. De igual forma el SO tampoco puede acceder a los parámetros SMART.

Es crítico evitar estos problemas y se remedia configurando la controladora RAID para funcionar en modo directo o JBOD anulando de facto su funcionalidad.

Entonces ¿qué ocurre con la protección de la caché de escritura ofrecida por la controladora? Los fabricantes de unidades SSD tienen en cuenta este detalle y añaden una batería interna.

La gestión de unidades SSD, un mundo nuevo

¿Quiere decir esto que no existen controladoras RAID para SSD? la respuesta es que si y a la vez que no, porque curiosamente, las nuevas controladoras RAID SSD, sólo ofrecen los modos RAID 0 y RAID 1 para permitir que las unidades estén conectadas de forma directa al OS.

En todo caso las nuevas unidades NVMe ofrecen tasas de lectura por encima de los 3000 MB/s dejando obsoletas a las controladoras simplemente porque no hay ancho de banda para conectar varias unidades en un único bus PCIe.

¿Existe una mejor arquitectura para gestionar estas unidades?.

La respuesta vendría de la mano de los nuevos servidores de almacenamiento Direct-Attach. Estos servidores conectan el bus PCIe de cada unidad NVMe directamente al bus PCIe de las distintas CPUs. De esa forma se aprovecha todo el potencial del servidor.

^{Esquema de un servidor Direct-Attach, fuente ServeTheHome.}

Fin de este análisis, no soy un experto así que cualquier dato que consideres se puede ser mejorado te invito a que comentes y compartas 😁

Canonical MAAS, Metal-As-A-Service, y provisiona tus nodos bare metal de forma elegante

Julián Mulet — Fri, 01 Oct 2021 07:26:48 +0000

Introducción

Por razones de rendimiento y/o costes no todas las aplicaciones Cloud Native están alojadas en los grandes proveedores de nube global al estilo de Amazon AWS, Google Cloud o Microsoft Azure.

También ocurre con muchos otros servicios que no están pensados para la nube y continúan ejecutándose en servidores bare metal dentro de los distintos centros de datos que no pertenecen a estos operadores globales.

Para estos casos Canonical, la empresa detrás de Ubuntu Linux, tiene disponible una potente herramienta libre de lo más interesante a la vez que desconocida para muchos administradores de sistemas.

Me refiero a MAAS con la que podrás gestionar todos tus servidores de forma desatendida pudiendo elegir entre VMWare ESXi, Windows, CentOS, RHEL y, como no, Ubuntu.

MAAS tiene dos entidades para poder gestionar la infraestructura TIC de una empresa siendo la entidad principal el controlador de región.

Este controlador ofrece la interfaz Web y una API REST y los servicios globales para gestionar nuestra infraestructura privada (DNS, NTP, Syslog, Squid Proxy).

Mi consejo es que esté alojado en tu proveedor de nube de confianza por ser una infraestructura de Alta Disponibilidad (HA) u opcionalmente puedes alojarla en tu infraestructura siguiendo estas indicaciones. En ambos casos la base de datos Postgres tiene que ser externa y en configuración HA.

Por otro lado, en cada rack, debemos instalar el controlador de rack, la otra entidad de MAAS, que provee de los servicios locales necesarios para gestionar nuestros nodos (PXE, IPMI, DHCP, TFTP, ISCSI, NTP).

NOTA: El controlador de rack estará alojado en la propia infraestructura del rack y podemos optar por una instalación con soporte HA.

^{* Sólo visible correctamente con el tema oscuro}

MAAS nos permite definir distintas zonas de disponibilidad que reflejarán zonas separadas físicamente bien sea por rack, sala o centro de datos. Estas zonas nos permiten declarar zonas de fallo aisladas, al estilo de los grandes proveedores de nube, para darnos una idea de cómo distribuir mejor las aplicaciones de HA.

Servidores

Cada servidor físico controlado por MAAS estará configurado para que pueda ser apagado, reseteado o encendido a través de su BMC (IPMI, iLO, etc.) y para arrancar desde la red por PXE-boot.

NOTA: en MAAS a los servidores se les llama máquina/machine y a al resto de dispositivos, routers, switch, etc., dispositivos/devices.

Para MAAS cada nodo está en un punto de su ciclo de vida:

Nuevo/New: Podemos dar de alta manualmente una nueva máquina o puede ser detectada cuando arranque por PXE-boot si se detectan automaticamente los parametros para acceder a su BMC.
Puesta en servicio/Commissioning: MAAS arranca la máquina desde una imagen de Ubuntu para recopilar el listado del hardware y añadirlo a su inventario.
Lista/Ready: el administrador puede pasar a configurar los interfaces de red, particiones de disco, etc.
Asignada/Allocated: el administrador ya ha definido su configuración de disco y de red asignando sus IPs que pasan a ser reservadas para esta máquina.
Desplegada/Deploying: MAAS instala el OS y configura automáticamente los interfaces de red y las particiones de disco.
Liberada/Releasing: el administrador puede dar de baja una máquina liberándola, MAAS iniciará un proceso para borrar el disco de la máquina y dejará de estar disponible para albergar servicios.

Sin entrar en profundidad vamos a ver algunos ejemplos del inventario de un servidor en MAAS:

^Resumen:

^{Configuración de red:}

^{Configuración de almacenamiento:}

Networking

Es una de las partes más potentes ya que nos permite dar de alta todos los recursos relacionados con nuestra red IP.

Fábrica

Es la principal forma de agrupar a los recursos de red.

Una fábrica la forman todos los recursos que tienen como finalidad atender a un servicio concreto sin relación con otros. Por ejemplo, podemos tener 3 servidores sobre los que trabaja nuestro cluster de Kubernetes con rangos de red y VLANs distintas a otros 2 servidores que dan soporte a un cluster Proxmox VE.

En esta línea, podemos ver en la imagen inferior que hay dos fábricas con distintas subredes y VLANs dentro de ellas.

^{Detalle de una subred:}

NOTA: la primera VLAN de una fábrica no está marcada/untagged ya que es la utilizada para arrancar los nodos por PXE-boot y es obligatorio que tenga el servicio DHCP activado para asignar al menos una IP al servidor.

Otra forma de entender el concepto de fábrica es que se recomienda configurar nuestros switches y trunks para permitir conectividad directa a nivel de capa 2 dentro de la misma mientras que la comunicación entre distintas fábricas necesariamente pase por un router capa 3.

Espacio

Es la otra forma de agrupar a los recursos de red, por ejemplo, podemos tener un espacio WAN y otro LAN o DRBD o cualquier concepto que represente una distinción importante común dentro de las distintas Fábricas.

Máquinas Virtuales

Otra característica que nos ofrece MAAS es la posibilidad de dar de alta a nuestros servidores como servidores de VM para crear sobre ellos nuevas máquinas que a efectos prácticos son idénticas a las físicas pudiendo desplegar los servicios en cualquiera de ellas.

Canonical ha elegido LXD como soporte para crear las VM lo cual es bastante interesante ya que es una implementación nueva de LXC que entra dentro de la virtualización ligera por lo que podemos esperar que se aprovechen al máximo los recursos de nuestro hardware.

Imágenes

Para poder trabajar con los distintos sistemas operativos, MAAS, nos ofrece el apartado para gestionar las imágenes de los mismos.

Por defecto trabaja con Ubuntu y CentOS pero se pueden cocinar imágenes personalizadas o añadir otros sistemas incluido Windows y sus licencias para poder realizar también instalaciones desatendidas.

Otra detalle importante es que podemos trabajar con otras arquitecturas, como por ejemplo arm64, de forma que también es una herramienta útil para gestionar infraestructuras de IoT o Edge computing.

Hasta aquí hemos visto los conceptos más importantes ya que este post sólo pretende ser una introducción conceptual a esta herramienta tan interesante. La documentación oficial es muy buena y el resto es cuestión de probarla y adquirir experiencia 😉.

Recursos útiles para mejorar tus publicaciones en Markdown

Julián Mulet — Fri, 24 Sep 2021 11:16:05 +0000

Recientemente he empezado a publicar en Dev.to para mejorar mi curriculum online y, cómo es algo nuevo para mi, he recopilado algunos recursos para usarlos de guía.

Esta es la lista de los que más me han gustado:

Siente libre de explorarlos 😉

Configura AutoFirma con el DNIe en Ubuntu Linux

Julián Mulet — Fri, 24 Sep 2021 07:54:46 +0000

Nota: este post es la continuación de
Configura tu DNIe en Ubuntu Linux para Chrome y Microsoft Edge.

AutoFirma es el sistema de firma electrónica desarrollado por la administración pública en España.

Con este software podemos aprovechar el certificado digital de nuestro DNIe para firmar cualquier documento generando un fichero nuevo con el sufijo _signed.csig.
Este fichero permite verificar que el original está firmado por nosotros y que no ha sufrido ninguna modificación.

AutoFirma está desarrollado en Java por lo que vamos a instalar el soporte JRE por defecto en Ubuntu:

sudo apt install default-jre

A continuación descargamos el fichero comprimido de AutoFirma para sistemas Linux desde la web oficial y lo instalamos:

mkdir -p /tmp/AutoFirma
wget -P /tmp/AutoFirma https://estaticos.redsara.es/comunes/autofirma/1/6/5/AutoFirma_Linux.zip
unzip /tmp/AutoFirma_Linux.zip -d /tmp/AutoFirma
sudo dpkg -i /tmp/AutoFirma/AutoFirma_1_6_5.deb

Nota: Al abrir AutoFirma con el DNIe insertado te pedirá que insertes el PIN:

La primera vez que abras el programa marca la opción No volver a mostrar... de la parte inferior de la ventana y a continuación pulsa en el botón Usar cualquier certificado:

Se abrirá la pantalla principal:

Y te recomiendo que utilices los siguientes ajustes accediendo al menú Herramientas -> Preferencias:

Para comprobar que funciona podemos firmar un fichero local arrastrándolo al cuadro de la ventana principal o pulsando en el botón Seleccionar ficheros a firmar:

Se abrirá una ventana con los certificados disponibles, selecciona el certificado para firmar:

El resultado debe ser similar a este:

Si necesitas hacer el proceso contrario, o sea verificar que una firma es valida, usa la opción del menú Ver firma:

Selecciona el fichero de firma y comprueba el resultado:

Por último, para realizar ciertos tramites con la administración pública será necesario convocar al programa desde el navegador Web, en mi caso uso Chrome pero debería funcionar con el resto sin problemas.

Abre este enlace para probar la firma electronica y pulsa en el botón Firmar. Saldrá un aviso de seguridad xdg-open para que permitas abrir la aplicación AutoFirma desde el navegador:

Y repite el proceso de seleccionar un fichero, introducir el PIN y usar tu certificado para firmar:

¡Si todo ha ido bien el resultado debe ser el siguiente! 🎉:

Configura tu DNIe en Ubuntu Linux para Chrome y Microsoft Edge

Julián Mulet — Thu, 23 Sep 2021 07:06:23 +0000

En España tenemos la opción de usar el certificado digital de nuestro DNIe para acceder a los servicios online de la administración pública.

Si eres usuario de Linux te habrás encontrado con varias guías basadas en Firefox pero no es el caso si usas Chrome, Chromium o el mismísimo Microsoft Edge 😉.

Nota: Esta guía está basada en Ubuntu LTS 20.04.

A estas alturas ya sabrás que para acceder al certificado necesitas un lector de tarjetas Smart Card y doy por sentado que ya dispones de él, más info en la web oficial.

Lo primero que haremos es instalar el soporte para el lector y las herramientas para gestionar la base de datos de certificados del sistema:

sudo apt update
sudo apt install pcscd pcsc-tools
sudo apt install libnss3-tools

Ahora introduce el DNIe en el lector y comprueba que es capaz de leerlo:

pcsc_scan

El segundo paso es crear la base de datos de certificados para el usuario actual. La crearemos sin protección por password por lo que, por seguridad, evitaremos que pueda ser leída por otros usuarios del sistema.

cd "${HOME}"
mkdir -p ~/.pki/nssdb
certutil -d ~/.pki/nssdb -N --empty-password

Cuando te pida password pulsa Enter:

Asignamos los permisos adecuados:

chmod 700 ~/.pki/nssdb

Para ver que funciona usa el siguiente comando:

certutil -d "sql:${HOME}/.pki/nssdb" -L

Lo normal es que esté vacía:

Descarga el software para distribuciones basadas en Debian/Ubuntu desde la web oficial o pulsa aquí para el resto de distribuciones.

Cuando se inicie la descarga acepta la alerta de seguridad del navegador:

E instala el paquete con el siguiente comando:

sudo dpkg -i ~/Descargas/libpkcs11-dnie_1.6.6_amd64.deb

¡PRECAUCIÓN!! El siguiente paso es necesario para no dañar la base de datos. HAY QUE CERRAR TODOS los navegadores y en mí caso particular, cómo utilizo el Chrome, he introducido el primer comando. Tu solo tienes que usar el adecuado para tu navegador.

pkill -o chrome
pkill -o msedge
pkill -o chromium

Y ya podemos añadir el módulo que gestiona nuestro DNIe:

modutil -add "DNIe" -dbdir "sql:${HOME}/.pki/nssdb" -libfile /usr/lib/libpkcs11-dnie.so

Comprueba que aparece en el listado:

modutil -list -dbdir ~/.pki/nssdb/

Ahora solo nos queda abrir el navegador pulsando en el siguiente link de verificación del certificado. El servicio te pedirá que introduzcas el PIN del DNIe, a continuación podrás seleccionarlo y esperar que la validación se complete correctamente:

Y eso es todo, espero que os sea de utilidad 😄.

Nota: este post continua con
Configura AutoFirma con el DNIe en Ubuntu Linux
en el caso de que necesites usar AutoFirma.