Utilizar interfaz gráfica en WSL2 para Windows 10, para aplicaciones Qt, QML y PySide2 con servidor VcXsrv

En esta ocasión vamos a configurar WSL2 para poder ejecutar aplicaciones gráficas de Qt. El método consiste en utiliza un servidor de video externo para la distribución Linux que estés usando, existiendo varias opciones de servidor a instalar en Windows 10, yo utilicé VcXsrv Windows X Server.

Descargamos e instalamos VcXsrv

Una vez instalado, es necesario arrancar la aplicación XLaunch utilizando las siguientes configuraciones:

Si tienes una distribución Ubuntu 18.04 instalada en tu WSL2, encontrarás un archivo de configuración en la ruta /etc/profile.d/wsl-integration.sh el cual contiene la siguientes líneas de configuración:

        export DISPLAY=${WSL_HOST}:0

        export LIBGL_ALWAYS_INDIRECT=1

Estas variables de entorno, indicarán al sistema que la aplicación será lanzada en la dirección DISPLAY y se utilizarán las librerías de OpenGL locales o remotas, poniendo 1 o 0 en LIBGL_ALWAYS_INDIRECT.

Esto es importante ya que ciertas aplicaciones se ejecutarán normalmente con la opción LIBGL_ALWAYS_INDIRECT=1 y con la opción Native opengl, del servidor de video, activada. Por otro lado, hay aplicaciones (en especial QML) que necesitan arrancar el servidor de video con la opción Native opengl desactivada, y la línea que corresponde a LIBGL_ALWAYS_INDIRECT debe ser comentada.

Hasta el momento, he probado aplicaciones gráficas en 3 escenarios distintos. Estos escenarios son:

• QtWidgets (Qt para escritorios programado en C++)
• QML (Qt para escritorios programado en QML y C++)
• Qt5 PySide2 (Qt para escritorios programado en Python)

Para todos los casos, es necesario instalar qt5-default

$ sudo apt install qt5-default

Aplicaciones QtWidgets:

Para ejecutar aplicaciones programadas en Qt5 es necesario instalar los siguientes paquetes:

$ sudo apt install (EN REVISION)

Verificamos que las variables de entorno estén correctas, es decir, DISPLAY debe apuntar a la IP de tu PC (puede ser localhost) y LIBGL_ALWAYS_INDIRECT=1

Aplicaciones QML:

Para ejecutar aplicaciones programadas en QML es necesario instalar el siguiente paquete:

$ sudo apt install libqt5qml5 

En caso de desarrollo, en necesario instalar también el siguiente paquete:

$ sudo apt install qt5declarative

Adicional, es necesario arrancar el servidor de video (VcXsrv) con la siguiente configuración:

Como se indicaba anteriormente, para que esto funcione, la opción LIBGL_ALWAYS_INDIRECT debe estar comentada, es decir la variable de entorno LIBGL_ALWAYS_INDIRECT no debe existir.

Aplicaciones Qt5 PySide2:

Para ejecutar aplicaciones programadas en Python con PySide2, fue necesario instalar el siguiente paquete:

$ pip3 install pyside2

Errores comunes:

Un error común es por ejemplo, que aparezca el mensaje "qt.qpa.plugin: Could not load the Qt platform plugin "xcb" in "" even though it was found." esto indica que faltan controladores por instalar, una buena opción es la de activar la variable de entorno QT_DEBUG_PLUGINS=1, lo cual permitirá mostrar información sobre el proceso de ejecución de la aplicación Qt.

$ export QT_DEBUG_PLUGINS=1

Esto permitirá determinar que controladores están faltando en nuestro sistema.

Compilar la libreria QSerialBus para Qt 5.12.0 en Ubuntu 18.04

Primero hay que clonar el código fuente con git:

git clone git://code.qt.io/qt/qtserialbus.git

Luego ingresamos a la carpeta qtserialbus y ejecutamos

RUTA_QT/Qt/5.12.0/gcc_64/bin/qmake

para configurar el código, posteriormente ejecutamos make.

Luego de que finalice la compilación, ejecutamos make install, las librerías deberían instalarse en RUTA_QT/Qt/5.12.0 quedando lista para su uso.

Hacer librerias para Qt

En el proyecto donde se encuentra el código fuente de la librería, hay que configurar el archivo .pro de la siguiente forma:

QT += core

CONFIG += c++11

TARGET = milibreria

The following define makes your compiler emit warnings if you use

# any feature of Qt which as been marked deprecated (the exact warnings

# depend on your compiler). Please consult the documentation of the

# deprecated API in order to know how to port your code away from it.

DEFINES += QT_DEPRECATED_WARNINGS

# Build as a library

TEMPLATE = lib

win32:CONFIG += dll

# You can also make your code fail to compile if you use deprecated APIs.

# In order to do so, uncomment the following line.

# You can also select to disable deprecated APIs only up to a certain version of Qt.

#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \

libreria.cpp

HEADERS += \

libreria.h

Luego  en el header libreria.h se coloca una macro a la clase Q_DECL_EXPORT que sirve para exportar la definición de la librería.

 class Q_DECL_EXPORT MiLibreria : public QClaseBase

    Q_OBJECT

public:

    MiLibreria();

signals:

public slots:

private:

};

Una vez compilada se la incluye en el proyecto donde va a ser usada en el archivo .pro agregando la ruta de la librería y de los headers de la siguiente forma:

INCLUDEPATH += rutaDeLosHeaders
LIBS += -L"rutaDeLaLibreria" -lmilibreria

Compilar la librería QMqtt para Qt 5.12.0 en Ubuntu 18.04

Primero hay que clonar el código fuente con git:

git clone git://code.qt.io/qt/qtmqtt.git

Luego ingresamos a la carpeta qtmqtt y ejecutamos

RUTA_QT/Qt/5.12.0/gcc_64/bin/qmake

para configurar el código, posteriormente ejecutamos make.

Luego de que finalice la compilación, ejecutamos make install, las librerías deberían instalarse en RUTA_QT/Qt/5.12.0 quedando lista para su uso.

Activar SSL en Ionos

En esta guía explicaré como instalar un certificado SSL en un servidor de Ionos, para esto deberías haber adquirido un dominio en Ionos, con esto podrás pedir el certificado SSL gratis.

Al activar el certificado, Ionos te descargará un archivo llamado _.TU-DOMINIO.com_private_key.key la cual es tu llave privada, deberás guardar este archivo.

Adicional a este archivo, deberás descargar el SSL Certificate (TU-DOMINIO.com_ssl_certificate.cer) y el Intermediate Certificate (_.TU-DOMINIO.com_ssl_certificate_INTERMEDIATE.cer), estos archivos deben ser concatenados en un solo archivo el cual se puede llamar (_.TU-DOMINIO.com_pem.pem).

La concatenación de estar realizada de tal forma que obtengas el siguientes resultado:

-----BEGIN CERTIFICATE----- (SSL Certificate: TU-DOMINIO.com_ssl_certificate.cer) -----END CERTIFICATE---- -----BEGIN CERTIFICATE----- (Intermediate Certificate: _.TU-DOMINIO.com_ssl_certificate_INTERMEDIATE.cer) -----END CERTIFICATE----

Procura que no queden espacios al comienzo, entre los contenidos, y al final de los mismos para que no se produzcan errores.

Estos archivos deben ser copiados a tu servidor en la carpeta /etc/ssl/nginx (en caso de que utilices nginx) y luego es necesario editar el archivo de configuración del sitio, en mi caso /etc/nginx/sites-available/odoo-443

Dependiendo del caso, hay que editar o agregar estas líneas:

ssl_certificate /etc/ssl/nginx/_.TU-DOMINIO.com_pem.pem; ssl_certificate_key /etc/ssl/nginx/_.TU-DOMINIO.com_private_key.key;

Para terminar, solo es necesario reiniciar el servidor Nginx, ejecutando:

$ sudo systemctl restart nginx

Agrandar una partición en un servidor Linux

Vamos a redimensionar el tamaño de la partición /dev/sda1, la cual tiene un tamaño de 100GiB y tiene instalado el sistema operativo Ubuntu Server, y contiene una partición /dev/sda2 que corresponde al swap del sistema, con un tamaño de 8,7 GiB. Queremos aumentar la partición /dev/sda1 a 190GiB y el Swap con el espacio restante. La unidad actualmente tiene capacidad para 200GiB.

Para redimensionar el tamaño de la unidad, primero hay que desactivar la partición del Swap, comentado la línea que corresponde en el archivo /etc/fstab.

# swap was on /dev/sda2 during installation
# /dev/sda2 none swap sw 0 0

Luego reiniciamos el sistema para que los cambios surtan efecto.

Ejecutamos

# fdisk /dev/sda

Imprimimos las particiones actuales tecleando p en fdisk y dando Enter, lo que debería dar algo similar a lo siguiente:


Disco /dev/sda: 200 GiB, 214748364800 bytes, 419430400 sectores
Unidades: sectores de 1 * 512 = 512 bytes
Tamaño de sector (lógico/físico): 512 bytes / 512 bytes
Tamaño de E/S (mínimo/óptimo): 512 bytes / 512 bytes
Tipo de etiqueta de disco: dos
Identificador del disco: 0x00065433

Dispositivo Inicio  Comienzo     Final  Sectores Tamaño Id Tipo
/dev/sda1   *           2048 191406250 191404203  91,3G 83 Linux
/dev/sda2          191410176 209715199  18305024   8,7G 82 Linux swap / Solaris

Entonces eliminamos la partición /dev/sda5 tecleando d y dando Enter, y luego escogemos la opción 2 cuando se nos pregunte.

Número de partición (1,2, valor predeterminado 2): 2

Guardamos los cambios tecleando w y dando Enter.

Volvemos a abrir ejecutar

# fdisk /dev/sda

Borramos la partición 1 y creamos una nueva con la opción n

Tipo de partición
   p   primaria (0 primaria(s), 0 extendida(s), 4 libre(s))
   e   extendida (contenedor para particiones lógicas)
Seleccionar (valor predeterminado p): p
Número de partición (1-4, valor predeterminado 1): 1
Primer sector (2048-419430399, valor predeterminado 2048): 2048
Último sector, +sectores o +tamaño{K,M,G,T,P} (2048-419430399, valor predeterminado 419430399): +190G

Crea una nueva partición 1 de tipo 'Linux' y de tamaño 190 GiB.
Partición #1: contiene un ext4 en la firma.

¿Desea eliminar la firma? [S]í/[N]o: N

Guardamos los cambios con w.

Ahora es posible reiniciar el sistema para que los nuevos cambios surtan efecto.

Tras el reinicio ejecutamos

# fdisk -l

Y nos dará como resultado lo siguiente:

Disco /dev/sda: 200 GiB, 214748364800 bytes, 419430400 sectores
Unidades: sectores de 1 * 512 = 512 bytes
Tamaño de sector (lógico/físico): 512 bytes / 512 bytes
Tamaño de E/S (mínimo/óptimo): 512 bytes / 512 bytes
Tipo de etiqueta de disco: dos
Identificador del disco: 0x00065433

Dispositivo Inicio Comienzo     Final  Sectores Tamaño Id Tipo
/dev/sda1              2048 398460927 398458880   190G 83 Linux

Con esto hemos redimensionado la partición, ahora es necesario redimensionar el sistema de archivos, para lo cual ejecutamos lo siguiente:

# resize2fs -p /dev/sda1

El sistema de ficheros de /dev/sda1 está montado en /; hace falta cambiar el tamaño en línea
old_desc_blocks = 6, new_desc_blocks = 12
El sistema de ficheros en /dev/sda1 tiene ahora 49807360 bloques (de 4k).

Con esto la unidad ya está redimensionada, ahora es necesario retornar el Swap, para lo cual crearemos una partición nueva para el Swap

Ejecutamos
# fdisk /dev/sda

Y luego creamos una nueva partición con n, y seleccionamos las siguientes opciones

Tipo de partición
   p   primaria (1 primaria(s), 0 extendida(s), 3 libre(s))
   e   extendida (contenedor para particiones lógicas)
Seleccionar (valor predeterminado p): p
Número de partición (2-4, valor predeterminado 2): 2
Primer sector (398460928-419430399, valor predeterminado 398460928): 398460928
Último sector, +sectores o +tamaño{K,M,G,T,P} (398460928-419430399, valor predeterminado 419430399): 419430399

Crea una nueva partición 2 de tipo 'Linux' y de tamaño 10 GiB.

Luego cambiamos el tipo de partición con la opción t, y seleccionamos la partición 2 e ingresamos 82 que corresponde al tipo de particón Linux Swap:

Orden (m para obtener ayuda): t
Número de partición (1,2, valor predeterminado 2): 2
Código hexadecimal (escriba L para ver todos los códigos): 82

Editamos nuevamente el archivo /etc/fstab descomentando la línea del swap anteriormente comentada.

Acceso a un servidor por SSH mediante clave SSH

Configuración del equipo local

En caso de no tener una clave, hay que generarla con el comando:

ssh-keygen -t rsa -b 2048 -C "Descripción de la clave email@dominio.com"

Pedirá el nombre de salida, por defecto id_rsa, en mi caso puse mis nombre y apellidos, los archivos se guardarán en la carpeta ~/.ssh

Creamos un archivo de configuración para la conexión llamado config, dentro de la carpeta de claves, es decir:

~/.ssh/config

Y dentro del mismo agregamos algo similar a:

PubKeyAuthentication yes
IdentityFile ./path/to/key

Configuración en el servidor

En el servidor remoto es necesario agregar la clave publica en el archivo:

~/.ssh/authorized_keys

Hay dos formas de hacerlo, la primera mediante el comando:

$ ssh-copy-id -i ~/.ssh/id_rsa user@host -p port

La segunda forma mediante el comando:

$ cat ~/.ssh/id_rsa.pub | ssh user@host -p port "mkdir -p ~/.ssh && cat >>  ~/.ssh/authorized_keys"

Debemos asegurarnos que los permisos de la carpeta .ssh sean 755 y del archivo authorized_keys sean 644.

Para impedir el acceso al servidor mediante contraseñas y con root, editamos el archivo /etc/ssh/sshd_config, cambiando lo siguiente:

PermitRootLogin no 
PasswordAuthentication no

Reiniciamos el servicio:

$ systemctl restart sshd

Con esto deberíamos poder ingresar al servidor utilizando una llave ssh.

Tips:
Para eliminar un footprint generado de algún servidor usar:
ssh-keygen -f "~/.ssh/known_hosts" -R "DIR.IP.DEL.HOST"


Referencias:
https://www.stackscale.com/es/blog/configurar-llaves-ssh-servidor-linux/
https://www.ssh.com/ssh/config/
https://www.ssh.com/ssh/copy-id
https://serverfault.com/questions/253313/ssh-returns-bad-owner-or-permissions-on-ssh-config
https://askubuntu.com/questions/311558/ssh-permission-denied-publickey