[BLOG].rdiez.es

Las miniaturas (thumbnails) no se generan en Ubuntu 24.04 LTS

Tue, 02 Jun 2026 00:00:00 +0000

Uno de los fallos más molestos que te puedes encontrar al realizar un update del sistema es que las miniaturas (thumbnails) de las imágenes dejen de generarse, mostrando en su lugar un icono genérico. Si echas un vistazo a tus carpetas ocultas, verás que todas estas miniaturas fallidas acaban almacenadas en la ruta ~/.cache/thumbnails/fail.

En esta ocasión vamos a solucionar este problema de raíz mediante la creación de un perfil seguro de AppArmor para Nautilus, permitiendo que el sistema vuelva a renderizar tus previsualizaciones sin comprometer tu seguridad.

¿Por qué ocurre esto?

El culpable detrás de este comportamiento es una nueva política de seguridad restrictiva en Ubuntu 24.04 relacionada con los espacios de nombres de usuario no privilegiados (unprivileged user namespaces).

Nautilus (el gestor de archivos de GNOME) utiliza por debajo una herramienta de aislamiento llamada bubblewrap. Su función es crear un entorno seguro (sandbox) para abrir y procesar las imágenes. De este modo, si un archivo estuviera corrupto o tuviera código malicioso, no podría infectar tu sistema.

El problema surge porque las directivas estrictas de AppArmor bloquean el funcionamiento de bubblewrap. Al no poder ejecutarse el sandbox, Nautilus falla de manera silenciosa y envía todas las miniaturas directamente a la carpeta de errores (fail).

Solución: Crear el perfil de AppArmor para Nautilus

Aunque existen métodos drásticos como desactivar esta restricción a nivel global en todo el kernel, no es lo recomendable. Lo ideal es aplicar una solución quirúrgica: indicarle a AppArmor que confíe específicamente en Nautilus.

Crear el archivo de configuración

Abrimos una terminal y ejecutamos el siguiente comando para crear un nuevo perfil de AppArmor utilizando el editor de texto nativo nano:

1

sudo nano /etc/apparmor.d/nautilus

Dentro del archivo vacío, vamos a pegar las reglas necesarias para otorgar el permiso requerido:

1
2
3
4
5
6
7
8
9


abi <abi/4.0>,
include <tunables/global>

profile nautilus /usr/bin/nautilus flags=(unconfined) {
 userns,

 # Site-specific additions and overrides. See local/README for details.
 include if exists <local/nautilus>
}

Para guardar los cambios en nano, presionamos la combinación de teclas Ctrl + O, pulsamos Enter para confirmar el nombre, y finalmente salimos con Ctrl + X.

Cargar el nuevo perfil en el sistema

Para que Ubuntu aplique las nuevas reglas inmediatamente sin necesidad de reiniciar el ordenador, lanzamos el siguiente comando en la terminal:

1

sudo apparmor_parser -r /etc/apparmor.d/nautilus

Limpieza del historial y reinicio

Una vez solucionado el bloqueo de seguridad, debemos obligar a Nautilus a reintentar la creación de las miniaturas que ya habían quedado marcadas como “fallidas”.

Vaciar la caché de errores

Ejecutamos este comando para limpiar el historial de imágenes corruptas en el sistema:

1

rm -rf ~/.cache/thumbnails/fail/*

Reiniciar el gestor de archivos

Por último, cerramos por completo la instancia de Nautilus que está corriendo en segundo plano:

1

nautilus -q

¡Listo! Con todo esto, la próxima vez que abras tu gestor de archivos y entres en tus carpetas de imágenes o vídeos, verás cómo se empieza a poblar de nuevo con todas las miniaturas generadas de forma instantánea y totalmente segura, como siempre debería haber sido.

PD: Imagen de banner generada con I.A.

Solucionar el menú contextual en blanco de Opera bajo Wayland en Linux

Tue, 12 May 2026 00:00:00 +0000

Utilizando Opera bajo Linux y Wayland (en mi caso Fedora y Ubuntu), me encontré con un problema bastante molesto (otro más de la lista): al pulsar con el botón derecho sobre algunas zonas del navegador, especialmente la barra de pestañas, el menú contextual aparecía completamente en blanco.

Después de varias pruebas, descubrí que el problema estaba relacionado con la implementación Wayland/Ozone que hace Opera.

La solución pasa por forzar a Opera a ejecutarse utilizando XWayland, mientras se solucione definitivamente.

Vamos a ver cómo hacerlo de forma permanente sin afectar a posibles upgrades que nos machaquen los ficheros de configuración:

Creamos el directorio local de aplicaciones de usuario si no existe ya:

1

mkdir -p ~/.local/share/applications

Copiamos el fichero .desktop de Opera original:

1

cp /usr/share/applications/opera.desktop ~/.local/share/applications/

Editamos el fichero:

1

nano ~/.local/share/applications/opera.desktop

Tenemos que modificar todas las líneas que comiencen por Exec, añadiendo el parámetro: `–ozone-platform=x11

Nos debería quedar algo parecido a esto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


❯ cat ~/.local/share/applications/opera.desktop

[Desktop Entry]
Version=1.0
Name=Opera
GenericName=Web browser
Comment=Fast and secure web browser
TryExec=opera
Exec=opera --ozone-platform=x11 %U
Terminal=false
Icon=opera
Type=Application
Categories=Network;WebBrowser;
MimeType=text/html;text/xml;application/xhtml_xml;x-scheme-handler/http;x-scheme-handler/https;x-scheme-handler/ftp;application/x-opera-download;
Actions=new-window;new-private-window;

[Desktop Action new-window]
Name=New Window
Exec=opera --new-window --ozone-platform=x11
TargetEnvironment=Unity

[Desktop Action new-private-window]
Name=New Private Window
Exec=opera --incognito --ozone-platform=x11
TargetEnvironment=Unity

Por último, cerramos completamente Opera:

1

pkill opera

Con esto, al volver a iniciar el navegador, el problema debería haber desaparecido por completo:)

En mi caso, esta solución funcionó tanto en Ubuntu como en Fedora 44.

PD: Imagen de banner generada con I.A.

Instalar K8sQuest en Linux con Podman Rootless: Solución a Cgroups

Tue, 14 Apr 2026 00:00:00 +0000

Recientemente me topé con K8sQuest. Se trata de una plataforma de aprendizaje gamificada, donde vamos a familiarizarnos con Kubernetes a través de diferentes misiones, donde algo se se romperá… y nos tocará diagnosticarlo y solucionarlo. Se ejecuta completamente en local, utilizando Kind (Kubernetes in Docker/Podman) para levantar bajo el capó el cluster con el que vamos a interactuar.

Al correr el instalador, él mismo trata de instalar el cluster con Kind, pero al utilizar en mi equipo Podman en modo rootless (sin privilegios de root), me topé de frente con un muro en forma de error:

1
2
3


🔧 Creating Kubernetes cluster...
enabling experimental podman provider
ERROR: failed to create cluster: running kind with rootless provider requires setting systemd property "Delegate=yes", see [https://kind.sigs.k8s.io/docs/user/rootless/](https://kind.sigs.k8s.io/docs/user/rootless/)

En este post vamos a ver por qué ocurre esto, cómo solucionarlo, y unas pequeñas indicaciones sobre cómo empezar a jugar con K8sQuest en nuestro entorno Linux.

El problema: Systemd y la delegación de Cgroups

Cuando usamos Kind con Podman rootless, el sistema intenta crear contenedores que actúan como “nodos” de nuestro clúster de Kubernetes. Estos nodos necesitan gestionar sus propios límites de CPU y memoria utilizando cgroups v2.

Por defecto, y por motivos de seguridad, systemd bloquea que un usuario normal delegue estos controles. Aunque la documentación oficial recomienda modificar los ficheros de configuración de systemd o usar systemctl --user, muchas veces estas soluciones fallan silenciosamente o simplemente no son las más sencillas.

La solución

En lugar de pelearnos con la configuración global de nuestra sesión o reiniciar servicios a lo loco, la forma más efectiva que me ha funcionado es inyectar el permiso directamente en el momento de la ejecución del propio instalador.

Para ello, vamos a envolver nuestro script de instalación con systemd-run. Esta herramienta nos permite lanzar un proceso creándole un “scope” (un entorno efímero) donde le pasamos exactamente la propiedad que necesita: Delegate=yes.

Nos situamos en el directorio del repositorio clonado de K8sQuest y lanzamos la instalación así:

1

systemd-run --scope --user -p "Delegate=yes" ./install.sh

Al ejecutarlo, verás un mensaje fugaz indicando que se está ejecutando como una unidad de systemd (ej. Running as unit: run-XXXX.scope), y a continuación la instalación continuará sin problemas hasta el final, creando el clúster correctamente, y todas las dependencias necesarias de K8sQuest.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


❯ systemd-run --scope --user -p "Delegate=yes" ./install.sh
Running as unit: run-r2e1b14ae02bf40a7bc0041218fe81c35.scope; invocation ID: 40e8bc6093734d0da4ec058c445ef224
🎮 K8sQuest Installation
========================

✅ Python 3.14 detected
✅ Prerequisites OK

📦 Installing Python dependencies...

[notice] A new release of pip is available: 26.0 -> 26.0.1
[notice] To update, run: pip install --upgrade pip
✅ Python packages installed

enabling experimental podman provider
No kind clusters found.
🔧 Creating Kubernetes cluster...
enabling experimental podman provider
Creating cluster "k8squest" ...
 ✓ Ensuring node image (kindest/node:v1.35.0) 🖼 
 ✓ Preparing nodes 📦 
 ✓ Writing configuration 📜 
 ✓ Starting control-plane 🕹️ 
 ✓ Installing CNI 🔌 
 ✓ Installing StorageClass 💾 
Set kubectl context to "kind-k8squest"
You can now use your cluster with:

kubectl cluster-info --context kind-k8squest

Have a nice day! 👋
Switched to context "kind-k8squest".
🏗️ Setting up k8squest namespace...
namespace/k8squest created
🛡️ Configuring safety guards (RBAC)...
serviceaccount/k8squest-player created
role.rbac.authorization.k8s.io/k8squest-player-role created
rolebinding.rbac.authorization.k8s.io/k8squest-player-binding created
clusterrole.rbac.authorization.k8s.io/k8squest-viewer created
clusterrolebinding.rbac.authorization.k8s.io/k8squest-viewer-binding created
✅ Safety guards configured

🚀 Setup Complete!

To start playing, use the shortcut:
 ./play.sh

Empezando a jugar con K8sQuest

Una vez que el instalador ha terminado, ya tenemos nuestro clúster operativo y corriendo en Podman de forma totalmente transparente y sin comprometer la seguridad de nuestro sistema usando la cuenta root.

Para empezar a trabajar con él, los pasos habituales son:

Verificar el clúster

Podemos asegurarnos de que el clúster de Kind se ha levantado correctamente comprobando los nodos (recuerda que si usas Podman, quizás tengas que exportar la variable KUBECONFIG si el instalador te lo ha indicado):

1

kubectl get nodes

Se debería ver el nodo o nodos de K8sQuest en estado Ready.

1
2
3
4


❯ kubectl get nodes
Alias tip: k get nodes
NAME STATUS ROLES AGE VERSION
k8squest-control-plane Ready control-plane 5m40s v1.35.0

Arrancar el juego

Para iniciar el juego, tan solo tenemos que abrir una terminal en el directorio donde clonamos los archivos de K8sQuest y ejecutar:

1

./play.sh

Al aceptar, comenzará nuestra primera misión: “Fix the Crashing Pod”

Nos hace una serie de indicaciones muy importantes para poder jugar:

Debemos abrir una nueva ventana/pestaña de terminal, desde donde “jugaremos” realmente.
Utilizaremos el comando kubectl para aplicar las soluciones.
Volveremos a esta pestaña para verificar la solución.

Limpiar el cluster de K8sQuest

Como todo el clúster está contenido dentro de nuestro entorno de usuario de Podman, se puede gestionar cómodamente. Si en algún momento necesitamos parar el clúster para liberar recursos de la máquina, se puede hacer usando el CLI de Kind indicando el proveedor experimental:

1

KIND_EXPERIMENTAL_PROVIDER=podman kind delete cluster --name k8squest

Con todo esto, ya tenemos un entorno de Kubernetes funcional, ligero y seguro en nuestro Linux para seguir trasteando y aprendiendo con K8sQuest. ¡Nos vemos en el próximo post!

PD: La imagen del banner de este post ha sido generada con IA.

Adiós Evernote, bromas las justas

Tue, 11 Nov 2025 00:00:00 +0000

Adiós Evernote, y gracias por estos 10 años… o no.

He sido usuario de Evernote durante más de una década. Más de 1.300 notas, clasificadas, etiquetadas, mantenidas y sincronizadas a través de todos mis dispositivos. Durante mucho tiempo fue una herramienta útil, estable y, sobre todo, con un precio razonable. No tenía intención de cambiar. Para mi era, simplemente, la mejor.

Cuando Evernote fue comprada por Bending Spoons, lo primero que llegó fueron las subidas de precio. Considerables subidas de precio. En aquel momento, conseguí un descuento para renovar, quedando el precio sobre unos 40€-50€, y decidí darles una oportunidad: venían actualizaciones frecuentes, algunas mejoras interesantes, y la sensación de que el producto seguía vivo. Hasta aquí, bien. El nuevo Evernote cumplió con lo prometido y siguieron contando con mi confianza.

El problema ha llegado ahora, con otro cambio de tarifas más. Para conservar más o menos la misma funcionalidad que tenía hasta hoy día, tengo que pasarme del plan Personal actual (99€ al año sin descuentos) al nuevo plan Advanced, que sale por la friolera de 199€ al año. El doble. Y ni siquiera hablamos de nuevas funciones o ventajas reales para justificarlo. Simplemente, pagar más por lo mismo. Porque sí.

Lo peor es que incluso pagando más, siguen imponiendo nuevos límites completamente absurdos, como la sincronización en tan sólo 5 dispositivos. Y esto en el plan Advanced. En el plan de pago un escalón por debajo, meten límites como sincronización en 3 dispositivos, 1.000 notas, o 20 cuadernos. Esto parece una auténtica broma. Llevo años pagando Evernote precisamente porque podía olvidarme de ese tipo de restricciones. Ahora quieren convertir ese aspecto básico (sobre todo en un plan de pago) en un “privilegio” caro.

Esto, para mí, es la gota que colma el vaso.

Es algo similar a lo que me ocurre con Netflix u otros servicios de streaming. Constantes subidas de precio y más limitaciones impuestas, publicidad, etc.

No voy a pagar bajo ningún concepto el doble para mantener exactamente lo mismo que hasta ahora. No voy a aceptar restricciones descabelladas pensadas para forzar al usuario al plan más caro. Y sobre todo, no voy a seguir confiando mis notas a una empresa que cambia las reglas de juego año sí, año también.

La confianza, una vez rota, no se recupera.

Y ahora, a migrar

Sé que no va a ser divertido mover más de 1.300 notas. Sé que me llevará tiempo reestructurar todo, elegir otra aplicación, y adaptarme. Pero prefiero invertir ese esfuerzo ahora que seguir atrapado en una plataforma que ha dejado claro cómo entiende a sus usuarios: como una fuente de ingresos que se puede exprimir cada año un poco más.

Hace años sospechaba que no era buena idea el atarme a un formato propietario y confiar todas mis notas a una empresa que podría “cortar el grifo” en cualquier momento. Debí haber escuchado más atentamente a mi voz interior. Incluso el propio Evernote a día de hoy impone restricciones a la hora de exportar tus propias notas, límites completamente artificiales que sólo buscan el atarte en su plataforma.

Por fortuna, la migración a día de hoy no es complicada utilizando herramientas de terceros, ya que puedo exportar mis notas fácilmente con herramientas como Evernote ENEX Exporter, e importarlas manteniendo su formato prácticamente intacto en Joplin u Obsidian. Estas herramientas te hacen completamente dueño de tus datos, sin atarte a nada. Ambas tienen sus pros y contras, por lo que tengo tiempo por delante para poder elegir el reemplazo más adecuado.

Así que este es mi punto final con Evernote.

Adiós Evernote.

No volveré.

Jamás.

PD: Imagen de banner generada con IA

Solucionar el cierre de Microsoft Edge en Linux (Wayland) al descargar Archivos

Tue, 04 Nov 2025 00:00:00 +0000

Si eres usuario de escritorio de Linux, probablemente estés usando Wayland, como servidor gráfico. Y si también eres de esas personas que utilizas Microsoft Edge, es posible que te hayas topado con un problema frustrante en las últimas versiones del navegador: se cierra por completo (crashea) en el instante en que intentas descargar un archivo cualquiera.

No parece que sea algo puntual. Afortunadamente, el problema tiene un diagnóstico claro y una solución bastante sencilla. Vamos a solucionar este problema paso a paso:

¿Qué está pasando?

Cuando el navegador crashea, lo primero que debemos hacer es ejecutarlo desde una terminal para ver qué nos dice. Si ejecutas microsoft-edge y provocas el fallo, probablemente verás un registro de error similar a este de libwayland: exported surface had an invalid role

1
2
3
4
5


❯ microsoft-edge
[...errores omitidos...]
[505387:505387:1104/130749.871196:ERROR:ui/events/platform/wayland/wayland_event_watcher.cc:47] libwayland: zxdg_exporter_v2#25: error 0: exported surface had an invalid role
[...errores omitidos...]
[1] 505387 trace trap (core dumped) microsoft-edge

Para los de la Logse: Cuando intentas descargar algo, Edge (basado en Chromium) intenta abrir el diálogo de “Guardar como” usando el protocolo nativo de Wayland. Sin embargo, le asigna un “rol” (un tipo de ventana) que tu compositor de Wayland (como Mutter en GNOME o KWin en KDE) no entiende o considera inválido. Este desacuerdo causa un error fatal y el navegador se cierra sin más explicaciones.

La Solución, Paso a Paso

La solución es forzar a Microsoft Edge a no usar Wayland de forma nativa, sino que se ejecute a través de XWayland, una capa de compatibilidad para aplicaciones X11, que existe especialmente para este tipo de situaciones.

Paso 1: Verificar la Solución

Primero, vamos a confirmar que esta es la solución. Cierra por completo todas las ventanas de Microsoft Edge que pudieras tener abiertas.

Luego, abre una terminal y ejecuta el siguiente comando:

1

microsoft-edge --ozone-platform=x11

Este comando le dice a Edge: “Ignora Wayland y ejecútate usando la capa de compatibilidad X11 (XWayland)”.

Ahora, con el navegador abierto desde esa terminal, intenta descargar un archivo. El diálogo de “Guardar como” debería aparecer sin problemas y el navegador ya no se cierra.

Nota: Es posible que en la terminal veas algunos errores nuevos, como GetVSyncParametersIfAvailable() failed. ¡No te preocupes! Estos son avisos menores no fatales, relacionados con la capa de compatibilidad, y puedes ignorarlos con seguridad. Lo importante es que el crash ha desaparecido.

Paso 2: Aplicar la Solución Permanente

Ahora que ya sabemos cual es el problema, y cómo corregirlo, vamos a hacer que este cambio sea permanente para que Edge siempre se inicie con esta configuración, sin importar si lo abres desde el icono de tu dock o desde el menú de aplicaciones.

Para ello, modificaremos el archivo .desktop (el lanzador) de la aplicación.

Copiar el lanzador a tu directorio local:

No vamos a editar el archivo del sistema directamente, ya que un sudo es innecesario y una actualización del navegador podría borrar nuestros cambios. En su lugar, lo copiaremos a nuestro perfil de usuario. Ten en cuenta que el nombre del archivo podría variar dependiendo de si utilizar la version estable, dev, etc.

1

cp /usr/share/applications/microsoft-edge.desktop ~/.local/share/applications/

Abrir el archivo para editarlo:

Ahora, abre este nuevo archivo con un editor de texto. Tomemos nano como ejemplo:

1

nano ~/.local/share/applications/microsoft-edge.desktop

Modificar las líneas Exec:

Dentro de este archivo, verás varias líneas que comienzan con Exec=. Estas líneas le dicen al sistema cómo ejecutar el programa. Tienes que encontrar todas las líneas Exec= que ejecuten el binario principal (como Exec=/usr/bin/microsoft-edge-stable %U o Exec=/usr/bin/microsoft-edge-stable --in-private-browsing) y añadirles el flag --ozone-platform=x11.

Hay que asegurarse de añadirlo después del comando pero antes de cualquier variable como %U o --new-window.

Ejemplo (Antes):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


[Desktop Entry]
...
Exec=/usr/bin/microsoft-edge-stable %U
...
[Desktop Action new-window]
...
Exec=/usr/bin/microsoft-edge-stable --new-window
...
[Desktop Action new-private-window]
...
Exec=/usr/bin/microsoft-edge-stable --in-private-browsing

Ejemplo (Después):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


[Desktop Entry]
...
Exec=/usr/bin/microsoft-edge-stable --ozone-platform=x11 %U
...
[Desktop Action new-window]
...
Exec=/usr/bin/microsoft-edge-stable --ozone-platform=x11 --new-window
...
[Desktop Action new-private-window]
...
Exec=/usr/bin/microsoft-edge-stable --ozone-platform=x11 --in-private-browsing

Guardar y Salir:

Por seguir con el ejemplo anterior, en nano, guardamos pulsando Ctrl + O (Enter) y luego salir con Ctrl + X.

¡Y eso es todo! Ahora usaremos automáticamente el lanzador modificado y completamente operativo :)

PD: Imagen de banner generada con I.A.

Añadir webs en la barra lateral de Opera One

Mon, 20 Oct 2025 00:00:00 +0000

Una de las ventajas que siempre he visto del navegador Opera ha sido su barra lateral, concretamente la capacidad de anclar sitios web personalizados en ella. Poder añadir una web como Evernote, por ejemplo, permite consultar notas rápidamente en un panel flotante sin interrumpir el flujo de trabajo principal, ni tener que cambiar de pestañas.

Es una funcionalidad que poco a poco van replicando otros navegadores, como Edge, Vivaldi, Brave…. pero encuentro que lleguen a funcionar tan bien como en Opera.

Con el cambio de navegador a la versión “Opera One”, esta funcionalidad ha desaparecido. La sección “Sitios Personalizados” ya no se encuentra en la configuración de la barra lateral, y debemos limitarnos a los sitios o servicios que ellos consideran.

Afortunadamente, la opción no ha sido eliminada por completo, sino que se encuentra oculta como una función experimental (una “flag”). Para poder recuperarla, el proceso es muy sencillo:

Activar la “Flag” experimental

Abre una nueva pestaña en Opera One.
Escribe lo siguiente en la barra de direcciones: opera://flags
Se abrirá el menú de funciones experimentales. En la barra de búsqueda superior (“Search flags”), vamos a buscar la flag que necesitamos: sidebar-site-panel
Aparecerá la opción “Custom user sites for browser sidebar”. Cambia la setting de “Default” a “Enabled”.
Para que se apliquen los cambios, si no lo pide al activar el cambio, es necesario reiniciar el navegador.

Añadir tus sitios web

Una vez reiniciado Opera, la opción volverá a estar disponible en el menú de configuración:

Clic en el icono de tres puntos (…) situado en la parte inferior de la barra lateral.
En el panel de “Configuración de la barra lateral”, desliza hacia abajo, casi hasta el final de las opciones.
La sección “Sitios personalizados” ha vuelto a aparecer.
Ya puedes clicar en “Añadir sitio personalizado” e introducir la URL que necesites (por ejemplo https://evernote.com).

Si bien esto soluciona el problema, es importante recordar que, al ser una “flag” experimental, Opera podría decidir eliminarla permanentemente en cualquier actualización futura. Pero, por el momento, esta es la solución :) Esperemos que dure mucho tiempo.

PD: Imagen de banner generada con I.A.

Caráturas en las Colecciones de Jellyfin

Tue, 30 Sep 2025 00:00:00 +0000

Desde la subida de precios de Plex, y su limitación de ciertas características gratuitas que yo utilizaba, he migrado todo mi contenido a Jellyfin. Hasta el momento ha ido todo sin problemas, excepto por un pequeño detalle del que me ha costado encontrar la solución. Se trata de las carátulas en las colecciones.

Cuando hay 2 o mas películas de la misma colección, se crea una en la sección correspondiente de Jellyfin agrupando a estas películas. El problema es que a veces, por algún motivo, estas colecciones quedan bloqueadas y no se le asignan las caráturas y metadatos correspondientes.

Reparar la colección

Para solucionar este problema, es necesario realizar dos pasos en orden:

Desbloquear la colección

Desde la interfaz web de nuestro Jellyfin, accedemos a las colecciones.
Hacemos click en el menú de la colección afectada (los 3 puntitos)

Vamos a “Edit Metadata” y bajamos hasta abajo del todo
Desmarcamos la opción “Bloquear este elemento para evitar futuros cambios”
Guardamos los cambios

Forzar la actualización de metadatos

Volvemos al menú de la colección afectada (los 3 puntitos)
Vamos a “Actualizar Metadatos”
Modo de refresco: “Refrescar todos los metadatos”
Marcamos las 2 opciones:
- “Reemplazar imágenes existentes”
- “Reemplazar imágenes trickplay existentes”
Pulsamos en Refrescar

Después de esto, la operación se meterá en la cola, y los metadatos de nuestra colección ya deberían aparecer según lo esperado

BuJo: de vuelta a lo analógico. Revolución inesperada

Mon, 07 Apr 2025 00:00:00 +0000

Hace un año, si alguien me hubiera dicho que abandonaría mis incontables apps de gestión del tiempo por un simple cuaderno de papel, le habría mirado como si hubiera perdido la cabeza. Soy informático, vivo entre pantallas, y mi necesidad (y obsesión) por optimizar cada minuto me llevó a probar decenas de apps con esta finalidad: Trello, Notion, Todoist, TickTick, Recordatorios de Apple, Asana…. hasta Obsidian con plugins personalizados. Pero hoy, mi herramienta de organización cabe en un simple A5 y no necesita batería.

Este ha sido mi viaje hacia el Bullet Journal minimalista.

El fracaso digital: cuando más apps = más caos

Durante años, creí que la respuesta a mi desorganización estaba en la próxima app todo-en-uno. Sin embargo, terminé con notificaciones constante, recordatorios olvidados o continuamente pospuestos, y una ansiedad constante por tener todo registrado en la correspondiente App.

Lo digital, paradójicamente, me distraía más de lo que me ayudaba. La saturación de opciones y la falsa sensación de control (¡tantos gráficos! ¡tantas etiquetas! ¡tantas opciones de visualización!) me hacían perder el foco constantemente.

El descubrimiento: Ryder Carroll y la simplicidad radical

Fue de pura casualidad que leí por primera vez sobre un curioso método, el Bullet Journal. Me llamó la atención, e investigué el método original de Ryder Carroll, incluso compré su libro El método Bullet Journal para profundizar más en tema… y algo hizo click: se trataba de un sistema analógico, flexible y centrado en acciones, no en decoraciones ni florituras.

Compré un cuaderno sencillo de puntos, un bolígrafo de tinta negra, que me pareció lo suficientemente cómodo, y empecé con las bases: Índice, Registro futuro, Registro mensual y Registro diario. Mi idea inicial era comprobar si este método era la revolución que prometía, y ver si podría adaptarme a este nuevo flujo tan disruptor con mi experiencia pasada.

Por qué lo analógico funciona (cuando lo digital falla)

Tras semanas de uso con el BuJo, me fui dando cuenta de sus grandes ventajas:

Menos distracciones, más atención: Sin notificaciones, sin tentaciones de abrir una red social al marcar una tarea. Escribir a mano me obliga a pensar antes de anotar, filtrando lo trivial.
Flexibilidad sin límites: ¿Una lista de la compra junto a un diagrama de flujo para un proyecto? En digital, eso implicaría tres apps distintas. En mi BuJo, son dos páginas contiguas.
Memoria física: Subrayar una tarea completada con un rápido gesto de la mano (¡el famoso X en lugar del check de toda la vida!) genera una satisfacción tangible que ningún checkmark digital iguala.
Privacidad y propiedad: Mis datos no están en la nube de nadie. Es mi sistema, sin algoritmos, sin suscripciones, sin actualizaciones que rompan mi flujo. Además fácilmente almacenable durante años y años, para futuras referencias.

Además, una ventaja muy grande para mi, es que en un mismo cuaderno, puedo tener TODAS mis tareas: personales, familiares, de trabajo, compromisos, etc. Esto hace que todo el foco de mi productividad se encuentre centralizado en un único sitio, con la seguridad que me da esto de saber que no tengo que rebuscar mis tareas por diferentes sitios, y posiblemente pasar algo por alto.

Mi estilo: minimalismo puro (nada de washi tapes, stickers o acuarelas)

En Instagram, Pinterest, etc, el Bullet Journal suele asociarse a diseños coloridos, caligrafía ornamental y páginas temáticas. Parece que se le pretende dar más importancia la forma que al contenido o la finalidad. Para mí, eso es completamente contraproducente. Mi regla es clara: si no suma funcionalidad, no entra. Uso únicamente:

Títulos en negrita con un rotulador más gordo del habitual (1mm).
Viñetas estándar (● para tareas, ○ para eventos, — para notas, * para prioridades).
Dos colores máximo: negro para lo habitual, rojo para prioridades o destacar los inicios de samana en el registro mensual.
Colecciones prácticas, no artísticas: Por ejemplo, tracker de migrañas, menús semanales, reformas del hogar, ideas de regalo para eventos, etc.

Secciones que me salvan el día a día

Tracker de migrañas: Anoto hora, intensidad, medicación, y posibles causas (café, estrés, sueño). Patrones que ninguna app de salud detectó.
Menú semanal + lista de la compra: Planificar comidas semanales evita el “¿qué cenamos hoy?” y los viajes improvisados y casi diarios al supermercado.
Reformas del hogar: Desde muestras de pintura pegadas con celo hasta cálculos de metros cuadrados para cambiar el suelo. Todo en un mismo sitio. Presupuestos, decisiones, materiales… Cualquier tipo de información que pueda ser útil a corto o largo plazo.

Conclusión: volver a lo esencial para avanzar

El Bullet Journal no es magia: es orden consciente. Como informático, me sorprende lo bien que convive mi amor por la tecnología con este regreso a lo analógico. Ahora, cuando abro mi cuaderno, no hay scroll infinito, no hay multitarea: solo yo, mis prioridades y el trazo limpio de una pluma sobre papel. En cierta manera, los momentos en los que me siento frente a mi BuJo llegan a ser relajantes.

De todas formas, no me he podido, ni querido desprenderme al 100% de lo digital. Sigo delegando en Google Calendar para beneficiarme de eventos y recordatorios futuros, como una especia de “anexo” a mi BuJo

¿Y si la verdadera productividad no está en hacer más cosas, sino en elegir mejor en qué enfocarse? Mi BuJo minimalista me lo recuerda cada día.

¿Has probado el Bullet Journal? ¿O sigues enganchado a lo digital? ¡Cuéntame en comentarios!

PD: Para los curiosos, mi setup actual es un cuaderno A5 de puntos, con 160 paginas de 120gr, y un Pilot VBall 0.5mm. Nada más. Nada menos.

PD2: Imagen de banner generada con IA

Mostrar la UI de Opera en español, en Linux

Fri, 31 May 2024 00:00:00 +0000

Al instalar el navegador Opera desde el paquete .deb, nos encontramos con que el interfaz de usuario (UI) se encuentra en un perfecto inglés, y no es posible cambiarlo a otro idioma siguiendo los cauces normales.

Vamos a ver cómo configurar el navegador para que se muestre en español:

Nos vamos a la siguiente ruta, donde están los iconos de inicio de nuestras apps: /usr/share/applications
Editamos el correspondiente a Opera utilizando sudo: sudo nano opera.desktop
Tenemos que editar todas las llamadas “Exec” añadiendo el parámetro: --lang=es

Nos debería quedar algo así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


❯ cat opera.desktop 
[Desktop Entry]
Version=1.0
Name=Opera
GenericName=Web browser
Comment=Fast and secure web browser
TryExec=opera
Exec=opera --lang=es %U
Terminal=false
Icon=opera
Type=Application
Categories=Network;WebBrowser;
MimeType=text/html;text/xml;application/xhtml_xml;x-scheme-handler/http;x-scheme-handler/https;x-scheme-handler/ftp;application/x-opera-download;
Actions=new-window;new-private-window;

[Desktop Action new-window]
Name=New Window
Exec=opera --new-window --lang=es
TargetEnvironment=Unity

[Desktop Action new-private-window]
Name=New Private Window
Exec=opera --incognito --lang=es
TargetEnvironment=Unity

Al iniciar el programa de nuevo, ya debería de mostrarse como se espera :)

Forzar el borrado de recursos en Kubernetes

Wed, 22 May 2024 00:00:00 +0000

A veces, al borrar recursos (pods, jobs, pvc, etc) en Kubernetes, mediante kubectl delete, estos se quedan en estado “stucked” y nunca llega a finalizar su borrado.

Podemos forzar el borrado de estos elementos editándolos manualmente, y borrando la parte de finalizers.

Los Finalizers son claves que le indican a la API de Kubernetes que quedan recursos por eliminar o por limpiar (dependencias) antes de que se elimine este recurso en particular.

Por ejemplo, de esta situación inicial, con kubectl edit:

1
2
3
4


metadata:
 annotations:
 finalizers:
 - zookeeper.finalizers.platform.confluent.io

Pasaríamos a esta:

1
2
3


metadata:
 annotations:
 finalizers: []

Otra manera más radical, para borrar todos los elementos de un mismo tipo mediante CLI, sería:

1
2
3
4


for job in $(kubectl --namespace sandbox get jobs --no-headers | awk '{print $1}'); \
 do kubectl --namespace sandbox patch job $job --patch '{"metadata":{"finalizers":[]}}' \
 --type=merge; \
 done

Fix de problema de imágenes Docker con procesador M1

Mon, 15 Jan 2024 00:00:00 +0000

Al utilizar imágenes con arquitecturas genéricas en Docker se pueden generar incompatibilidades con los procesadores M1 Silicon

Podemos utilizar la capa de virtualización de Rosetta para solventar este tipo de problemas.

Metodo 1: exportar variable

Si estamos utilizando directamente la CLI, podemos exportar la siguiente variable previamente en la shell:

1

export DOCKER_DEFAULT_PLATFORM=linux/amd64

Metodo 2: corregir docker-compose

Si por el contrario estamos utilizando docker-compose, lo modificamos según el formato de fichero:

1

platform: linux/amd64

Por ejemplo:

1
2
3


kafka:
	image: confluentinc/cp-kafka:latest
	platform: linux/amd64

Metodo3: corregir dockerfile:

Otra opción si lo que utilizamos es un dockerfile:

1
2


ARG build_for=linux/amd64
- FROM --platform=$build_for python:3.9.13-slim AS base

Conexión por ssh sin passwords

Sun, 23 Jul 2023 00:00:00 +0000

Cuando utilizamos ssh a menudo, el poder conectar a equipos remotos sin memorizar contraseñas nos puede facilitar mucho la vida.

El equipo “servidor” será el equipo a donde vamos a conectar mediante ssh
El equipo “cliente” será el origen de la conexión.

Este tipo de autenticación funciona mediante el intercambio de claves. Nuestro servidor necesita tener la clave pública del cliente dentro de sus claves autorizadas para poder validar la conexión.

Generar claves

Para poder conectar a un “servidor” mediante ssh sin utilizar contraseñas, lo primero es verificar en el equipo “cliente” que ya cuenta con claves tanto pública como privadas:

1

ls -al ~/.ssh/id_*.pub

Si no las tiene, las generamos:

1

ssh-keygen -t rsa -b 4096

la opción -t significa el tipo
rsa es el protocolo. en este caso es el de por defecto
la longitud de la clave se define con -b 4096. Por defecto es 2048

Tras responder las preguntas, nos generará las claves en la ubicación predeterminada:

La clave privada se guardará en: .ssh/id_rsa
La clave pública se guardará en: .ssh/id_rsa.pub

Copiar clave pública

Necesitamos copiar nuestra clave pública al servidor al que vamos a acceder. Para ello hay 3 métodos:

comando ssh-copy-id
mediante ssh
manualmente

Copiar clave con ssh-copy-id

Simplemente lanzamos lo siguiente, indicando el user y hostname de nuestro servidor:

1

ssh-copy-id remote_username@remote_IP_Address

Copiar clave por ssh

Si ya tenemos acceso pos ssh al servidor, podemos enviar manualmente la clave publica:

1

cat ~/.ssh/id_rsa.pub | ssh remote_username@remote_ip_address "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

Copiar manualmente la clave

Cómo último método podemos agregar manualmente el contenido del archivo id_rsa.pub al archivo ~/.ssh/authorized_keys del servidor remoto. En Windows, este es el método más fácil.

Vemos el contenido de nuestra clave pública en el equipo cliente

1

cat ~/.ssh/id_rsa.pub

Dentro del equipo servidor, creamos un fichero, por ejemplo SSH_public_key con el contenido obtenido en el paso previo, y lo añadimos a nuestro authorized_keys

1

echo SSH_public_key >> ~/.ssh/authorized_keys

Si fuese necesario, corregimos permisos:

1

chmod -766 ~/.ssh

Listo!

Definir fichero .gitignore global

Sat, 22 Jul 2023 00:00:00 +0000

En Git podemos definir un fichero .gitignore de manera global en lugar que tener que definirlo en cada uno de los repositorios.

Para ello lo primero es crear el fichero .gitignore_global:

1

git config --global core.excludesfile ~/.gitignore_global

Ahora se puede editar el fichero de la misma manera que haríamos con un fichero común.

Hosting multisite con proxy y SSL

Thu, 15 Sep 2022 00:00:00 +0000

Hace unos días liberé una solución basada en docker-compose para poder alojar múltiples sitios web en un sólo servidor (mayormente RaspberryPi), utilizando un proxy inverso con nginx y generando automáticamente los certificados SSL con Let´s Encrypt

Se puede acceder públicamente a este repositorio en: https://github.com/rdiezsj/multisite-with-proxy-and-SSL-docker

La idea general es simple:

Tenemos X sites desplegados con docker, por ejemplo un Wordpress con su MariaDB, un DokuWiki, y un sitio web con HTML estático.

La solución genera certificados SSL automáticamente para que todos los sites sean accesibles mediante https.

A su vez, con el proxy inverso exponemos todos los servicios mediante una url única o subdominio, en lugar de tener que definir un puerto por cada uno de los servicios, por ejemplo: https://wordpress.midominio.com

Los volúmenes de datos se montan con persistencia, facilitando el poder utilizar soluciones de backup.

Es fácilmente configurable como un daemon.

Requisitos

Como requisitos, necesitamos:

Tener instalados Docker y Docker Compose
Tener un nombre de dominio. Ya sea contratado o gratuito
Tener un servidor con una dirección públicamente enrutable
Clonar el repositorio con la solución:

1

git clone https://github.com/rdiezsj/multisite-with-proxy-and-SSL-docker.git

Configuración

Es necesario modificar el archivo docker-compose.yml en base a nuestras necesidades, así como las variables definidas. Para una información mas detallada y actualizada es mejor leer directamente el README del propio repositorio.

Kubernetes en RaspberryPi con microk8s

Sun, 22 May 2022 00:00:00 +0000

Hoy en día cada vez está más extendido el uso de contenedores, y orquestación de los mismos con soluciones como Openshift o Kubernetes. Si en nuestro día a día es algo que con lo que tenemos que lidiar continuamente, o simplemente queremos trastear con algun proyecto personal, puede ser interesante tener un pequeño laboratorio en casa para testing.

Con nuestra querida RaspberryPi podemos montarnos un pequeño cluster (de momento lo vamos a dejar como standalone) que aunque no nos vaya a servir como entorno de producción, y no sea algo rápido, ni fácil, puede resultar tremendamente entretenido.

Para comenzar lo que vamos a necesitar va a ser muy sencillo:

RaspberryPi 4 con al menos 4GB de RAM
Tarjeta microSD de 64GB
Adaptador de corriente de mínimo 3A para alimentar la Raspberry
Otro equipo con el que conectaremos por ssh.

Preparación

Lo primero será preparar el S.O. de nuestra RaspberryPi. En esta ocasión vamos a utilizar Ubuntu Server.

Para ello vamos a descargar la ISO correspondiente de su web oficial y la cargamos en nuestra SD mediante Balena Etcher.

Enchufamos el adaptador de corriente y arrancamos nuestra placa. El proceso de arranque inicial suele llevar unos 5 minutos antes de que nos permita hacer login.

Accedemos a nuestra Raspberry mediante ssh, si no tenemos monitor y teclado. El login por defecto es:

user: ubuntu
pass: ubuntu

1

ssh ubuntu@192.168.200.204

Una vez dentro, lo primero que nos va a pedir es establecer una contraseña.

Actualizamos paqueteria

1
2
3


sudo apt update
sudo apt upgrade -y
sudo apt autoremove -y

Preparamos el S.O. para utilizar los cgroups. Para ello añadimos al final de la linea de arranque del fichero /boot/firmware/cmdline.txt, lo siguiente:

1

cgroup_enable=cpuset cgroup_enable=memory cgroup_memory=1

Inicialmente conectamos la Raspberry por cable de red, pero podemos opcionalmente dejar configurado el Wifi como “failover”

1

sudo nano /etc/netplan/50-cloud-init.yaml

1
2
3
4
5
6
7


 wifis:
 wlan0:
 dhcp4: true
 optional: true
 access-points:
 "SSID_name":
 password: "WiFi_password"

Corregimos nuestra zona horaria

1

sudo timedatectl set-timezone Europe/Madrid

Añadimos un nombre de host

1

sudo nano /etc/hostname

y finalmente reiniciamos

1

reboot

MicroK8s

A la hora de montar nuestro pequeño cluster de kubernetes, tenemos varias opciones:

La vía oficial de kubernetes
minikube
Kubernetes embebido de Docker desktop
microk8s

En nuestro caso, ya que estamos utilizando como base un sistema operativo, vamos a ir con la solucion de microk8s, ya que es desarrollada por la propia Canonical como paquete snap. Esto nos puede proporcionar más compatibilidad y simplicidad a la hora de mantenerlo al día.

Para ello, es tan simple como instalar el paquete.

1

sudo snap install microk8s --classic

La sintaxis para gestionar nuestro cluster con microk8s es: microk8s kubectl ******. Nuestra intencion es abstraernos lo máximo posible de esta sintaxis, y simplificarlo utilizando kubectl como un alias:

En este caso es bash pero si utilizaramos zsh habria que cambiar la ruta del fichero de aliases

1
2
3


echo 'export PATH=/snap/bin:$PATH' >> ~/.bashrc
echo "alias kubectl='microk8s kubectl'" >> ~/.bash_aliases
source ~/.bashrc

añadimos permisos a nuestro usuario

1
2
3


 sudo usermod -a -G microk8s ubuntu
 sudo chown -f -R ubuntu ~/.kube
	newgrp microk8s

Chekeamos que está running:

1

microk8s status --wait-ready

Añadimos algunos plugins esenciales, como el de Dashboard, Ingress Registry y DNS

1
2


microk8s status --wait-ready
microk8s enable dns ingress dashboard registry

Una pequeña descripción de cada uno de ellos

1
2
3
4
5


microk8s enable ingress # expone rutas HTTP and HTTPS desde fuera del cluster, hacia dentro del mismo.
microk8s enable dashboard # GUI grafica para la gestión del cluster mediante interfaz web
microk8s enable dns # crea registros DNS para los servicios y pods
microk8s enable storage # permite gestionar el storage que proporcionamos a los pods del cluster
microk8s enable registry # nos permite tener un registry local para almacenar las imágenes docker 

Verificamos que nuestros alias funcionan correctamente, y tenemos un nodo corriendo

1

kubectl get nodes

MetalLB

Vamos a instalar el Load Balancer, utilizando la solucion de MetalLB

1

microk8s enable metallb

Nos pedira un rango de IPS reservadas para gestionar. En mi Red casera voy a reservar estas: 192.168.200.220-192.168.200.249

Vamos a lanzar un pequeño deployment para verificar que nuestro balanceador está funcionando correctamente:

1
2
3


kubectl create deployment whoami --image=containous/whoami

kubectl expose deployment whoami --type=LoadBalancer --port=80

Podemos verificar que se ha asignado una de las IP reservadas:

1
2
3


ubuntu@RPI4:~$ kubectl get service whoami
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
whoami LoadBalancer 10.152.183.181 192.168.200.220 80:30341/TCP 4m55s

Ahora solo nos hace falta atacar la IP desde el navegador o con un simple curl

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


ubuntu@RPI4:~$ curl 192.168.200.220
Hostname: whoami-5d56c87b99-fxjvn
IP: 127.0.0.1
IP: ::1
IP: 10.1.117.20
IP: fe80::30ba:88ff:febb:a570
RemoteAddr: 10.0.1.1:51427
GET / HTTP/1.1
Host: 192.168.200.220
User-Agent: curl/7.81.0
Accept: */*

ubuntu@RPI4:~$

Dashboard

Para acceder a nuestro dashboard, necesitamos conocer la IP y puerto asignados al mismo:

1
2
3


ubuntu@RPI4:~$ kubectl -n kube-system get services | grep kubernetes-dashboard
kubernetes-dashboard NodePort 10.152.183.148 <none> 443:30353/TCP 15m
ubuntu@RPI4:~$

Con esto ya podemos acceder al dashboard desde fuera de nuestra raspbery PI

https://{server ip}:{port number}

En mi caso:

1

https://192.168.200.204:30353

Al acceder desde el navegador, nos pedirá autenticación. Necesitamos averiguar el token. Esta información la podemos obtener en la propia configuracion de microk8s

1
2


microk8s config | grep token
 token: NW4vWGJZUEkyMDdPWVZGRnVEVXlBVjhmWHNkaUpoQ1RBN29jVGMyek44Zz0K

Copiamos el token y lo pegamos en la UI.

Con esto ya tendríamos nuestro cluster con un único nodo corriendo y listo para trabajar con él. Más adelante veremos como añadir más nodos a este cluster, eliminarlos, etc.

Rollback de Mesa en Fedora 34

Fri, 30 Apr 2021 00:00:00 +0000

Hace apenas un par de días, y con una semana de retraso frente a la fecha inicial, se liberó la versión final de Fedora 34. Esta versión trae cambios muy esperados y más que comentados en otros medios como la inclusión de Gnome 40 👣, el uso de Btrfs 💾 como sistema de ficheros por defecto, o Pipewire 🔊 como servidor de sonido.

No es el objetivo de este post, pero en el uso del día a día se muestra como una release tremendamente pulida, y con la estabilidad habitual propia de Fedora.

Sin embargo, si usamos algunos modelos de GPU AMD como es mi caso (RX 5600 XT), es muy posible que al actualizar la paquetería del sistema empecemos a ver diversos glithces y artefactos gráficos. Estos problemas son ocasionados por la actualización de dos paquetes pertenecientes a la versión 21.0.3-1 de Mesa:

mesa-dri-drivers-21.0.3-1
mesa-filesystem-21.0.3-1

Parece que este bug ya ha sido detectado y corregido en su version 21.0.3-2. Sin embargo, si no queremos convivir con estos glitches tan molestos, lo ideal es revertir los cambios hasta que los paquetes con el bugfix finalmente entren en la rama estable de los repositorios.

Esto es algo muy sencillo, pero lo dejo por aquí por si alguien no sabe cómo hacerlo:

Lo primero sería ver la lista de versiones de paquetes que tenemos accesible en nuestro repo.

1

sudo dnf --showduplicates list mesa-dri-drivers

Una vez verficado que podemos ir la versión anterior, es tan facil como lanzar el downgrade de versión de la librería gráfica.

1

sudo dnf downgrade mesa-dri-drivers 21.0.2-1.fc34

Con esto, y tras el correspondiente reboot de la máquina, deberíamos habernos deshecho por completo de los problemas. Únicamente tenemos que tener cuidado de no actualizar estos paquetes a la hora de hacer cualquier tarea de upgrade.Podemos hacerlo de dos maneras distintas:

Omitirlo de manera permanente modificando el fichero /etc/dnf/dnf.conf y añadiendo la línea exclude=mesa-dri-drivers
o simplemente omitiéndolo al realizar un upgrade: dnf update --exclude=mesa-dri-drivers

Para verificar a qué versión se nos actualizaría:

dnf --showduplicates list mesa-dri-drivers

Uso de https en hosting compartido (Ionos)

Mon, 26 Apr 2021 00:00:00 +0000

Hace algunos años era habitual que casi la totatidad de páginas web se presentaran en un simple HTTP. Sin embargo, estando en 2021, este planteamiento es casi inviable. A día de hoy es poco menos que obligatorio el uso de SSL/TLS y https si queremos tener presencia en Internet de manera mínimamente viable.

En la mayoría de hostings hoy en día se nos suele ofrecer un certificado SSL de manera gratuita. Pero si tenemos más de un dominio puede que tengamos problemas para activar su correspondiente certificado.

El caso es especialmente sangrante en Ionos. El hosting ofrece una gran relación calidad/precio, sin embargo, si queremos un segundo certificado para otro dominio, nos obligan si o si a pasar por caja 💰. En una web o servicio profesional esto no es un problema tan grande ya que lo recomendable sería irnos a uno de estos certificados, pero si se trata de una página web pequeña o un servicio sin más pretensiones, lo ideal es aprovechar servicios de emision de certificados gratuitos del tipo de Let´s Encrypt. Y es aquí donde tenemos el gran problema, y es que Ionos no te permite gestionar este tipo de certificados que no tengas comprados a través de su plataforma.

Afortunadamente, hay soluciones para todo 😀

En este caso vamos a aprovechar el servicio gratuito que nos ofrece Cloudflare, el cual, además de una CDN, nos va a permitir encryptar las conexiones desde el navegados hasta Cloudflare. Además, nos va a servir para cualquier tipo de web. Tanto para una web en html estático generada con Hugo, como un servicio tipo NextCloud, o blogs como Wordpress.

El único pero que tenemos, es que para poder hacer uso de este “workaround”, nuestro servicio web no debe estar asociado a nuestro dominio raiz (ejemplo.com), sino a un subdominio (blog.ejemplo.com). Sí que se puede tener redireccionado el raiz a nuestro subdominio si lo queremos, en este caso, la redirección debería estar creada previamente para evitar sorpresas con la propagación de DNS.

El primer paso va a ser irnos a Cloudflare y crearnos una cuenta gratuita.
Una vez creada y activada la cuenta, nos vamos a la opcion de “Agregar sitio” y añadimos nuestro dominio principal (ejemplo.com). Seleccionamos cuenta gratuita y continuamos.
El siguiente paso escaneará la configuración DNS de nuestro dominio y sugerirá la configuración más transparente para nosotros. Debemos dejar la configuración por defecto según nos la sugiere.
A continuación nos indica que cambiemos los DNS de nuestro registrador. Esto varía según el registrador donde tengamos contratado nuestro hosting, pero en la propia pantalla nos indica los pasos más o menos ajustados.
El resumen a grandes rasgos sería eliminar las entradas DNS actuales de nuestro dominio raiz, y agregar los dos servidores de cloudflare que nos sugieren.
Con esto, tan sólo debemos esperar un mínimo de 24 horas para que se propague por los diferentes DNS mundiales y evitar sorpresas.

Por defecto, ya se genera y aplica el certificado gratuito, además de activar los servicios de CDN, con una configuración básica, por lo que despues del tiempo de espera podemos acceder sin problemas a nuestra web mediante https.

El último paso varía según lo que estemos exponiendo, pero en el caso de Wordpress por ejemplo, será necesario modificar la url del servicio a https, ademas de activar la redirección automática de http a https para que todo nuestro contenido sea servido de esta manera.

Como último apunte, a partir de ahora la gestion de nuestra zona DNS la debemos realizar desde Cloudflare. De esta manera cualquier otro dominio que creemos también se encontrará encriptado mediante el wildcard.

Gestión de dotfiles con stow

Sun, 21 Mar 2021 00:00:00 +0000

Antes de nada, conviene aclarar lo que entendemos por dotfiles. Se trata de los ficheros y directorios que encontramos en los sistemas Linux, los cuales mantienen la configuración a nivel de usuario de las aplicaciones. Estos ficheros suelen estar ocultos (con un . al inicio de su nombre), de ahí el hombre de “dot"files.

Es habitual subir estos ficheros a un repositorio de manera que si cambiamos de sistema, sea muy sencillo poder recuperar estos ficheros, y por consiguiente nuestra configuración de las aplicaciones.

Una manera muy cómoda de gestionar estos “backups”, es clonar nuestro repo en la máquina, y crear enlaces simbólicos directamente a los ficheros de los que queramos realizar la copia.

Vamos a ver como realizar este proceso desde cero, aprovechando la herramienta stow, la cual nos facilitará la gestion de nuestros enlaces simbólicos.

Crear repositorio para nuestros dotfiles

Lo primero es crear un repositorio (público o privado) donde alojaremos nuestros dotfiles. Personalmente, recomiendo Gitlab por encima de Github u otros servicios similares, por características y funcionalidades ofrecidas de manera gratuita.

Creamos el repo y lo inicializamos con un Readme.md para hacer todo más sencillo.

Una vez creado nuestro repo, vamos a nuestra máquina y nos lo clonamos, Pero antes vamos a establecer algunas configuracones de git que nos ahorrarán tiempo. Tan solo tenemos que sustituir los campos por nuestros datos reales:

1
2
3
4
5


git config --global credential.helper store

git config --global user.name "<NUESTRO_USERNAME>"
git config --global user.name "<NUESTRO NOMBRE COMPLETO>"
git config --global user.email "<NUESTRO EMAIL>"

Ahroa sí, ya podemos clonar el repo indicando nuestro usuario y/o ruta del repositorio creado

1
2


cd ~
git clone https://gitlab.com/<USERNAME>/dotfiles.git

Instalar GNU Stow

GNU Stow es una herramienta muy sencilla, basada en Perl, que nos va a facilitar la vida muchísimo a la hora de gestionar los enlaces simbólicos. Se encuentra directamente en los repositorios de la práctica totalidad de distribuciones, así que su instalación es tan sencilla como:

Ubuntu y basadas en Debian:

1

sudo apt install stow

Fedora y basadas en RedHat

1

sudo dnf install stow

Basadas en Arch

1

sudo pacman -Suy stow

Ejemplo práctico

Pongamos por ejemplo que queremos resguardar nuestras personalizaciones de Terminator, y la configuración que hemos aplicado para esta app a nivel de GTK.

Para ello entramos dentro de nuestra carpeta de dotfiles, y creamos aquí la estructura de ficheros que deseamos salvaguardar. Lo más habitual es crear una carpeta por aplicación, y dentro de ella replicamos la estructura a guardar tomando nuestro home como referencia. En este caso, vamos a guardar tambien todos los plugins y configuraciones que hemos añadido a nuestro terminator

1
2
3
4
5
6
7
8
9


cd ~/dotfiles/
mkdir terminator

mkdir -p .config/terminator
mkdir -p .config/plugins
mkdir -p .config/gtk-3-0

touch .config/gtk-3-0/gtk.css
touch .config/terminator/config

Con esto, hemos generado una estructura dentro de nuestra carpeta de dotfiles, tal que así:

1
2
3
4
5
6
7


terminator/
└── .config
 ├── gtk-3.0
 │   └── gtk.css
 └── terminator
 ├── config
 └── plugins

Ahora vamos a indicar a stow cuales son los ficheros y directorios que vamos a utilizar

1
2


cd ~/dotfiles
stow --adopt -nv terminator

el parámetro -nv le indica que muestre los cambios en modo verbose, pero sin aplicar ningún tipo de cambio. Si vemos que es correcto, podemos omitir el -n

1

stow --adopt -v terminator

con esto, podemos verificar que ha copiado los ficheros originales dentro de nuestra carpeta de dotfiles, y los ha sustituido por enlaces simbólicos a nuestro repositorio.

Con esto, cualquier cambio de configuración que realicemos, realmente se está haciendo sobre los ficheros de nuestro repositorio. Tan solo debemos realizar un commit y un push desde nuestro repositorio para que los ficheros estén a salvo en Git

Recuperar dotfiles

En caso de que hayamos instalado un nuevo sistema, y lo que queramos sea recuperar nuestro ficheros de configuración, el proceso sería muy similar.

Instalamos stow
Clonamos nuestro repositorio dentro de nuestro home
Indicamos a stow que cree los enlaces simbólicos necesarios. Lo lanzamos dentro del root de nuestra carpeta dotfiles

1
2


cd ~/dotfiles
stow -v terminator

Espero que esto os sea de ayuda. Personalmente, es algo que tengo siempre presente en cualquier sistema Linux que utilizo.

Algunas ideas para aplicar en nuestros “dotfiles”, son por ejemplo:

Terminator -> Emulador de terminal con soporte de tiling y plugins
.bashrc - Configuración de shell Bash
.zshrc - Configuración de shell Zsh
Oh-my-zsh
Configuraciones de Powerlevel10k
Ficheros de alias utilizados en bash o zsh
Configuraciones personalizadas de gtk
Fuentes o temas de gnome instalados para nuestro usuario.
Y un largo etc.

Comprimir y descomprimir en Linux

Fri, 12 Mar 2021 00:00:00 +0000

Comprimir y descomprimir

Una de las tareas más habituales en cualquier sistema operativo, es la compresión y descompresión de ficheros. Según el tipo de fichero, podemos realizar estas tareas de la siguiente manera en Linux, para los formatos de archivos más comunes:

Archivos .tar.gz
- Comprimir: tar -czvf empaquetado.tar.gz /carpeta/a/empaquetar/
- Descomprimir: tar -xzvf archivo.tar.gz
- Ver contenido sin descomprimir: tar -tf archivo.tar.gz
Archivos .tar
- Empaquetar: tar -cvf paquete.tar /dir/a/comprimir/
- Desempaquetar: tar -xvf paquete.tar
Archivos .gz
- Comprimir: gzip -9 index.php
- Descomprimir: gzip -d index.php.gz
Archivos .zip
- Comprimir: zip archivo.zip carpeta
- Descomprimir: unzip archivo.zip

Automatización con script

Para facilitarnos la compresión y descompresión de fichero, podemos añadir el siguiente script a nuestro .bashrc o .zshrc. De esta forma, solo tenemos que indicar extract o compress seguido del nombre del fichero, y podemos olvidarnos del resto de sintaxis particular del formato.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


## COMPRESSION FUNCTION ##
compress() {
 FILE=$1
 shift
 case $FILE in
 \*.tar.bz2) tar cjf $FILE $\* ;;
 \*.tar.gz) tar czf $FILE $\* ;;
 \*.tgz) tar czf $FILE $\* ;;
 \*.zip) zip $FILE $\* ;;
 \*.rar) rar $FILE $\* ;;
 \*) echo "Filetype not recognized" ;;
 esac
}

## EXTRACT FUNCTION ##
extract() {
 if \[ -f $1 \] ; then
 case $1 in
 \*.tar.bz2) tar xjf $1 ;;
 \*.tar.gz) tar xzf $1 ;;
 \*.bz2) bunzip2 $1 ;;
 \*.rar) unrar e $1 ;;
 \*.gz) gunzip $1 ;;
 \*.tar) tar xf $1 ;;
 \*.tbz2) tar xjf $1 ;;
 \*.tgz) tar xzf $1 ;;
 \*.zip) unzip $1 ;;
 \*.Z) uncompress $1 ;;
 \*.7z) 7z x $1 ;;
 \*) echo "'$1' cannot be extracted via extract()" ;;
 esac
 else
 echo "'$1' is not a valid file"
 fi
}

Dividir y unir ficheros

Contamos con un fichero muy grande que necesitamos dividir en partes más pequeñas o manejables, o el caso contrario… tenemos varios ficheros que necesitamos unir para obtener el fichero original.

Usamos split indicando el tamaño de las partes deseado

1

split -b 300m -d fichero_grande.tar.gz ficheros_troceados.tar.gz.par

Después se pueden unir con un simple cat

1

cat ficheros_troceados* > fichero_grande

Servidor Web sencillo con Python

Wed, 10 Mar 2021 00:00:00 +0000

A veces requerimos de un servidor web para poder compartir ficheros entre máquinas por http, pero no se requiere de las características de un servidor más avanzado tipo apache.

En estos casos, podemos aprovechar Python para levantar un servidor muy sencillo que nos saque del apuro.

Como es lógico, el único requisito que tenemos es tener instalado y disponible python. Esto podemos verificarlo con un simple: python --version

Para levantar el servidor, nos vamos a la carpeta que queramos compartir. Está se tomará como el root de nuestro pequeño servidor web

1

cd /tmp/carpeta_que_comparto

Una vez aquí, dependiendo de si es Windows o Linux, ejecutamos:

Linux y Mac python -m SimpleHTTPServer 8000
Windows o python3 python -m http.server 8000

El 8000 nos indica el puerto a levantar.

Una vez levantado, podemos solicitar ficheros que se encuentro dentro de la carpeta raiz como en cualquier otro servidor web

1

wget http://<IP_SERVIDOR>:8000/mi_fichero.txt

Como extra, podemos automatizar esto mediante el uso de un alias, añadiendolo a nuestro .bashrc, por ejemplo:

1

alias mini_server="python -m $(python -c 'import sys; print("http.server" if sys.version_info[:2] > (2,7) else "SimpleHTTPServer")')"

de esta forma, tan solo tendremos que ejecutar mini_server para que el servidor web se levante en la carpeta en que nos encontremos.

Escritorio Mate en Windows, con WSL2

Thu, 16 Jul 2020 00:00:00 +0000

Una de las mejores características de Windows en muchos años, es la implementación de WSL (Windows Susbystem Linux), la cual nos permite tener un linux viviendo debajo de nuestro sistema operativo, sin depender de virtualizaciones y con una integración máxima.

Con el lanzamiento de WSL2, esta implementación se amplía mucho más, sobre todo en cuestión de rendimiento, haciendo de ella una característica prácticamente obligatoria en cualquier instalación de Windows 10.

En esta ocasión vamos a instalar un Ubuntu con WSL2, con escritorio Mate, que trabajará con una integración perfecta con nuestro S.O.

Preparación

Actualización 19041

Para poder hacer uso de WSL2, es necesario que tengamos Windows 10 actualizado a la compilación 19041 o superior.

Podemos verificar esto abriendo una consola de poweshell y ejecutando uno de estos comandos:

1
2
3


ver

winver

En caso de la versión sea previa a 19041, necesitaremos actualizar el sistema desde Windows Update.

Activar WSL

ejecutamos una consola de Poweshell con privilegios de administrador, y lanzamos el siguiente comando para activar la característica

1

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart

Kernel WSL

Una vez activado, deberemos actualizar el kernel de WSL, preparándolo para la versión 2. Es tan simple como descargar e instalar el siguiente paquete:

https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi

Plataforma de máquina virtual

El siguiente paso será activar la virtualización, requisito para WSL2, tanto en la BIOS como en Windows.

Para activarlo en la BIOS, deberás seguir el manual de tu placa base, suele ser una simple opción dentro de las características de CPU que se debe activar

En windows, con una consola Powershell como administrador, lanzamos:

1

dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

WSL2 por defecto

Con esto, y tras reiniciar, ya tendremos todo listo. Lo siguiente será establecer WSL2 como la versión por defecto para cualquier distribución que instalemos

Instalar Distribución

En nuestro ejemplo vamos a instalar Ubuntu, aunque serviría a grandes rasgos cualquier otra.

Para ello podemos instalarlo desde la Windows Store.

https://www.microsoft.com/en-us/p/ubuntu/9nblggh4msv6

Durante el proceso de instalación nos pedirá user y pass para el usuario linux

Migrar distribución previa

En caso de que ya tuvieramos una distribución instalada previamente, y corriendo bajo WSL1, se puede migrar a la nueva versión.

Para verificar la version que tenemos podemos lanzar:

1

wsl -v -l

Para migrarla a versión 2:

1

wsl --set-version {DISTRIBUCION} 2

Instalar entorno de escritorio

El siguiente paso será instalar nuestro entorno de escritorio. Los más recomendables para usar bajo WSL son Mate, o xfce. Por preferencias personales, vamos a utilizar Mate.

Abrimos nuestro terminal conectando a la distribución (el propio icono que nos crea, la nueva terminal de windows, Mobaxterm, etc ) y nos aseguramos de que nuestra distro esté actualizada:

1

sudo apt update && sudo apt upgrade

ahora ya podemos instalar el propio escritorio mate

1

sudo apt install ubuntu-mate-desktop

antes de proseguir, vamos a aprovechar para corregir futuros problemas con el display y dbus:

añadimos las siguientes lineas al fichero ~/.bashrc

1
2
3


export DISPLAY=$(cat /etc/resolv.conf | grep nameserver | awk '{print $2}'):0

sudo /etc/init.d/dbus start &> /dev/null

Y creamos el fichero /etc/sudoers.d/dbus con el siguiente contenido, indicando nuestro usuario

1

{USUARIO} ALL = (root) NOPASSWD: /etc/init.d/dbus

Acceso al escritorio

Para abrir nuestro flamante escritorio mate, podemos hacerlo con un servidor x11, o mediante xRDP.

Con xRDP será como una conexión a un equipo cualquier, teniendo una única ventana.
La opción del servidor X11 nos da mas flexibilidad ya que podemos tratar las aplicaciones y ventanas de manera independiente, por lo que ese integrarán mejor con nuestro flujo de trabajo, por ello es la opción que vamos a utilizar

Instalar VcXsrv

Es tan simple como descargar la aplicación, instalarla, y lanzar Xlaunch.

https://sourceforge.net/projects/vcxsrv/

Esto nos abrirá un asistente donde dejaremos las opciones por defecto, a excepción del último paso:

Mobaxterm

En caso de que utilicemos Mobaxterm, al tener un servidor X11 ya integrado, puede dar conflicto con VcXsrv. Para solucionar esto, debemos editar nuestro fichero ~/.bashrc, y sustituir la linea:

1

export DISPLAY=$(cat /etc/resolv.conf | grep nameserver | awk '{print $2}'):0

por esta otra

1

export DISPLAY=:0.0

Iniciar Escritorio

Para iniciar nuestro escritorio, despues de asegurarnos de que tenemos VcXsrv, tan solo debemos lanzar en nuestro wsl:

1

mate-session &

Esto nos levantará una ventana completa donde podremos interactuar, o abrir nuevas aplicacaciones

Una opción que me gusta más, por integración, es lanzar en su lugar:

1

mate-panel &

Esto iniciará dos paneles básicos de Mate. El inferior podemos borrarlo pulsando sobre él con el botón derecho.

El superior, podemos personalizarlo haciendo click derecho y pulsando en preferencias. Personalmente me gusta configurarlo así:

De esta forma el panel siempre está accesible en la parte superior, y sin interferir con ninguna otra ventana.

Cualquier aplicación que abramos desde este panel, se abrirá como una ventana cualquier de Windows10, por lo que la integración con el S.O. anfitrión es total.

Visualizando métricas Con Grafana

Sat, 16 May 2020 00:00:00 +0000

Previamente hemos comenzado a crear nuestro «stack» de monitorización de forma básica.

Si bien con Chronograf podemos visualizar los datos de una forma fácil y rápida, utilizando Grafana podemos acceder a estos mismos datos almacenados en InfluxDB y mostrarlos de una forma mucho más avanzada y customizable.

Instalación de Grafana

Descargamos el paquete desde la página oficial de Grafana, según nuestra arquitectura. En mi caso, Debian para ARM7

https://grafana.com/grafana/download?platform=arm

1
2


wget https://dl.grafana.com/oss/release/grafana_6.4.4_armhf.deb
sudo dpkg -i grafana_6.4.4_armhf.deb

Tal como nos indica al finalizar la instalación, arrancamos y activamos como servicio

1
2


sudo /bin/systemctl restart grafana-server
sudo /bin/systemctl enable grafana-server

Configuración de Grafana

Accedemos a nuestro grafana y nos logueamos con la cuenta por defecto: admin / admin. Tras esto nos pedirá cambiar la password por una más segura.

http://192.168.0.X:3000/

Lo primero será añadir un nuevo Data Source tal como nos indica el asistente. Seleccionamos «InfluxDB» como origen, ya que es la BBDD que estamos utilizando:

Aquí debemos rellenar nuestros datos de InfluxDB (nombre de BBDD, user, Password, etc). Todos estos datos son los que hemos configurado durante la instalación previa que explicamos en el post anterior.

Tras pulsar en «Save and test» debería guardarnos el Data Source sin problemas. Si hubiera algún error, es necesario verificar de nuevo los datos introducidos.

Dashboard desde cero

Ha llegado el momento de crear nuestro primer dashboard. Aquí es donde encuentra todo el potencial de Grafana, y puede ser realmente complejo de llegar a entender, por eso es recomendable echarle un ojo a la documentación oficial.

Esto lo veremos más delante en profundidad, por el momento vamos a crear un dashboard con una única gráfica, como ejemplo.

Nos vamos a «New», y seleccionamos Query como primer paso.

Lo primero será seleccionar nuestro Data Source: InfluxDB

Ahora se nos mostrará un constructor de querys en blanco. En este ejemplo vamos a seleccionar los datos de memoria donde el host sea rpi2, y que nos haga una media de los valores:

Con esto ya tenemos nuestra gráfica de memoria.

En la siguiente opción «Visualization» podemos definir más como queremos que nos muestren los datos, por ejemplo:

unidades en bytes
líneas
valores mínimo, máximo y actual, etc

En general definimos el nombre de nuestra grafica, una descripción, etc.

Con esto ya podemos guardar nuestro dashboard con nuestra primera gráfica lista para ser visualizada.

Hay que tener paciencia y jugar mucho con las opciones, ayudándonos de la documentación oficial, pero se puede moldear los dashboards tal y como lo necesitemos, a nuestro gusto.

Dashboard desde plantilla

Otra manera para empezar a trabajar de forma rápida, es coger alguno de los dashboard ya creados que tiene grafana en su web:

https://grafana.com/grafana/dashboards

Podemos utilizar este como base, por ejemplo: https://grafana.com/grafana/dashboards/10578

Tan sólo necesitamos copiar su ID, e irnos a la opción de importar. Aquí pegaremos este ID, y lo importamos directamente:

Con esto ya tendremos nuestro primer dashboard operativo, de una forma muy fácil y rápida. Lógicamente habrá gráficas que no muestren datos, ya que estamos realizando una monitorizoción muy básica y la plantilla puede que tenga más orígenes de datos.

Como hemos dicho previamente, ahora lo importante es jugar con las diferentes opciones, ir adecuando los dashboards a nuestras necesidades.

En siguientes post iremos evolucionando nuestro sistema de monitorización hacia algo más completo ????

Temperatura y Ventiladores Con lm-sensors en AMD Ryzen

Thu, 16 Apr 2020 00:00:00 +0000

Uno de los mayores problemas de Linux frente a Windows, en arquitecturas AMD Ryzen, es el control de temperaturas y velocidad de ventiladores. Por poner un par de ejemplos claros:

En Windows puedo ver la temperatura de todos los sensores de mi motherboard, así como la gestión de ventiladores de la misma, sin ningún problema. En Linux solo me muestra la temperatura de CPU y GPU.
En Windows, mi GPU (una Radeon RX590) detiene automáticamente los ventiladores de la misma cuando trabaja a temperaturas inferiores a 50º. En linux los ventiladores se encuentran permanentemente al 50%. Aunque es una gráfica muy silenciosa, el sonido se llega a notar.

No obstante, en Linux hay poco que no se pueda hacer, así que en este post vamos a ver como tratar estos dos puntos

Ver todos los sensores en lm-sensors

Instalación de paquetes

Una herramienta básica en Linux para poder ver temperaturas, voltajes, rpm, etc, es lm-sensors, y su interfaz gráfica psensor. Vamos a instalarlo poniendo un ubuntu como ejemplo, aunque el paquete puede ser instalado en cualquier distribución

1

sudo apt install lm-sensors psensor

En Arch, sería

1

sudo pacman -Sy lm-sensors psensor

Una vez instalado, podemos lanzar la autodetección de los sensores, aunque el número de ellos que detecte será muy bajo:

1

sudo sensors-detect

Podemos ver la información de nuestros sensores con

1

sensors

Detección del hardware.

Ahora nos toca buscar un poco de información. Es necesario conocer el chipset que utiliza nuestra placa base. En mi caso, (una MSI X470 Pro Carbon), monta un chip nuvoTon NCT 6795D.

Con esta información en la mano, es necesario buscar de nuevo el kernel driver que da soporte a este chip. En este caso concreto, sería el NCT6775

una vez que tenemos el kernel driver que nos aplica, vamos a probarlo:

1

modprobe nct6775

Si ahora lanzamos sensors, nos debería mostrar mucha más información que antes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


ryzen-zos@ryzen-zos:~$ sensors
nct6795-isa-0a20
Adapter: ISA adapter
in0: +0.66 V (min = +0.00 V, max = +1.74 V)
in1: +1.02 V (min = +0.00 V, max = +0.00 V) ALARM
in2: +3.34 V (min = +0.00 V, max = +0.00 V) ALARM
in3: +3.41 V (min = +0.00 V, max = +0.00 V) ALARM
in4: +1.01 V (min = +0.00 V, max = +0.00 V) ALARM
in5: +0.15 V (min = +0.00 V, max = +0.00 V) ALARM
in6: +0.72 V (min = +0.00 V, max = +0.00 V) ALARM
in7: +3.33 V (min = +0.00 V, max = +0.00 V) ALARM
in8: +3.25 V (min = +0.00 V, max = +0.00 V) ALARM
in9: +1.82 V (min = +0.00 V, max = +0.00 V) ALARM
in10: +0.00 V (min = +0.00 V, max = +0.00 V)
in11: +0.67 V (min = +0.00 V, max = +0.00 V) ALARM
in12: +1.15 V (min = +0.00 V, max = +0.00 V) ALARM
in13: +0.68 V (min = +0.00 V, max = +0.00 V) ALARM
in14: +1.54 V (min = +0.00 V, max = +0.00 V) ALARM
fan1: 0 RPM (min = 0 RPM)
fan2: 590 RPM (min = 0 RPM)
fan3: 1048 RPM (min = 0 RPM)
fan4: 0 RPM (min = 0 RPM)
fan5: 675 RPM (min = 0 RPM)
fan6: 552 RPM (min = 0 RPM)
SYSTIN: +37.0°C (high = +0.0°C, hyst = +0.0°C) ALARM sensor = CPU diode
CPUTIN: +35.0°C (high = +115.0°C, hyst = +90.0°C) sensor = thermistor
AUXTIN0: +42.0°C (high = +115.0°C, hyst = +90.0°C) sensor = thermistor
AUXTIN1: -128.0°C sensor = thermistor
AUXTIN2: +45.0°C sensor = thermistor
AUXTIN3: -2.0°C sensor = thermistor
SMBUSMASTER 0: +35.5°C 
PCH_CHIP_CPU_MAX_TEMP: +0.0°C 
PCH_CHIP_TEMP: +0.0°C 
PCH_CPU_TEMP: +0.0°C 
intrusion0: ALARM
intrusion1: ALARM
beep_enable: disabled

amdgpu-pci-2600
Adapter: PCI adapter
vddgfx: +0.90 V 
fan1: 156 RPM (min = 0 RPM, max = 3200 RPM)
edge: +46.0°C (crit = +91.0°C, hyst = -273.1°C)
power1: 42.23 W (cap = 185.00 W)

k10temp-pci-00c3
Adapter: PCI adapter
Tdie: +35.1°C (high = +70.0°C)
Tctl: +35.1°C

Configuración

Como funciona correctamente, vamos a aplicar los cambios para que se lance automáticamente en cada inicio. Para ello modificamos el fichero /etc/rc.local

1

sudo nano /etc/rc.local

Y lo modificamos para que quede algo parecido a esto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.
modprobe nct6775
exit 0

Modificamos los permisos:

1

sudo chmod +x /etc/rc.local

Y con esto ya tenemos todo listo para obtener informacion de todos los sensores de nuestra placa base.

Controlar ventiladores

Utilizando el propio lm-sensors, y fancontrol, podemos controlar la velocidad y umbrales de todos los ventiladores de nuestro PC. En mi caso los tengo controlados desde la propia BIOS, pero me interesa que el comportamiento de los ventiladores de la GPU sea similar al de Windows: Que por debajo de 45-50 grados los ventiladores se detengan por completo.

En distribuciones basadas en arch, lo más rápido y cómodo es instalar la utilidad Corectrl desde los repositorios AUR, pero para otro tipo de distros es necesario compilar el código manualmente. Para ahorrarnos tiempo, vamos a utilizar fancontrol

1

sudo apt install fancontrol

Configuración

Ahora vamos a lanzar el asistente de configuración:

1

sudo pwmconfig

Esto nos lanzará un asistente muy claro en el que nos irá preguntado qué ventiladores queremos modular, los umbrales en que se activarán, la velocidad de cada uno de ellos, etc etc. Al finalizar nos generará el fichero de configuración en /etc/fancontrol

Un ejemplo de mi configuración:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


ryzen-zos@ryzen-zos:~$ cat /etc/fancontrol 
# Configuration file generated by pwmconfig, changes will be lost
INTERVAL=5
DEVPATH=hwmon0=devices/pci0000:00/0000:00:03.1/0000:26:00.0
DEVNAME=hwmon0=amdgpu
FCTEMPS= hwmon0/pwm1=hwmon0/temp1_input
FCFANS= hwmon0/pwm1=
MINTEMP= hwmon0/pwm1=45
MAXTEMP= hwmon0/pwm1=75
MINSTART= hwmon0/pwm1=100
MINSTOP= hwmon0/pwm1=0
MAXPWM= hwmon0/pwm1=255

Para iniciar el programa, lo lanzamos con

1

sudo fancontrol

Con todo esto, ya tenemos un comportamiento más o menos similar al encontrado en Windows. Además, modificando los ficheros de configuración, podemos cambiar las alertas, etiquetas de los sensores, etc. También podemos utilizar esta información para utilizar en extensiones de gnome o KDE…. Pero todo esto lo veremos en otros post.

Añadir Nuevos Nodos En InfluxDB (Linux Y Windows)

Mon, 16 Mar 2020 00:00:00 +0000

Vamos a seguir ampliando nuestro sistema de monitorización basado en Telegraf, InfluxDB y Grafana. En este post, vamos a ver cómo integrar otro nodo más a nuestro sistema, ya sea un equipo que tenga S.O. Linux, o Windows

Linux

Instalación

Para ilustrarlo con un ejemplo, voy a añadir mi NAS, que como podemos ver cuenta con sistema operativo Linux Debian 8:

1
2
3
4
5
6
7
8
9


root@ReadyNAS:~# cat /etc/*release*
PRETTY_NAME="ReadyNASOS 6.10.2"
NAME="Debian GNU/Linux"
VERSION_ID="8"
VERSION="8 (jessie)"
ID=debian
HOME_URL="http://www.debian.org/"
SUPPORT_URL="http://www.debian.org/support"
BUG_REPORT_URL="https://bugs.debian.org/"

También es importante asgurarse de la arquitectura de procesador que tenemos. En mi ejemplo, vemos que es ARMv7:

1
2
3


root@ReadyNAS:~# cat /proc/cpuinfo
processor : 0
model name : ARMv7 Processor rev 1 (v7l)

Teniendo toda esta información clara, procedemos a añadir el repositorio de Influx tal como hemos visto en post previos. Primero la key…

1

curl -sL https://repos.influxdata.com/influxdb.key | apt-key add -

y despues el repo. Es importante modificar el nombre de la distribución (jessie)

1

echo "deb https://repos.influxdata.com/debian jessie stable" | tee /etc/apt/sources.list.d/influxdb.list

Hacemos un apt update e instalamos Telegraf

1

 apt update && apt install telegraf

Configuración

Antes de nada, debemos de configurar Telegraf para indicarle qué información debe recoger, y dónde debe enviarla. Para ello modificamos el fichero de configuración

1

sudo nano /etc/telegraf/telegraf.conf

En la sección [[outputs.influxdb]] descomentamos la url correspondiente a http., y apuntamos a la IP de nuestro influxDB (la IP de nuestra raspberry en este caso)

1

 urls = ["http://192.168.0.11:8086"]

el nombre del database a utilizar

1

database = "telegraf"

y le indicamos que no cree la BBDD, ya que ya está generada. Únicamente tiene que conectarse a ella

1

 skip_database_creation = true

También dentro de este apartado, configuramos la autentificación tal como ya hicimos anteriormente en los post previos:

1
2
3


## HTTP Basic Auth
username = "telegraf"
password = "MIPASSWORD"

Con esto tendríamos una configuración básica. Podemos añadir más métricas que nos resulten interesante, como ya vimos anteriormente.

Reinicamos el servicio para que coja los cambios realizados:

1

sudo systemctl restart telegraf

y lo activamos como servicio para que levante automáticamente

1

sudo systemctl enable telegraf

Con esto, ya podemos ver los datos que se están recogiendo en Chronograf

Y tambien en nuestros dashboards de Grafana

Windows

Instalar cliente

Para instalar nuestro cliente Telegraf en Windows, lo primero es descargarnos el instalable correspondiente desde la propia [web de influx[(https://portal.influxdata.com/downloads/)

para x64 sería: https://dl.influxdata.com/telegraf/releases/telegraf-1.12.6_windows_amd64.zip

Extraemos el .zip descargado, y vemos que únicamente contiene dos ficheros:

telegraf.conf
telegraf.exe

Nos movemos estos dos ficheros a una carpeta que crearemos en la ruta: C:\Program Files\Telegraf

Configuración

Ahora vamos a configurar Telegraf. Para ello modificamos telegraf.conf. El fichero es prácticamente idéntico al que ya vimos en Linux justo arriba, por lo que el bloque [[outputs.influxdb]] nos quedaría algo como esto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


[[outputs.influxdb]]
 ## The full HTTP or UDP URL for your InfluxDB instance.
 ##
 ## Multiple URLs can be specified for a single cluster, only ONE of the
 ## urls will be written to each interval.
 # urls = ["unix:///var/run/influxdb.sock"]
 # urls = ["udp://127.0.0.1:8089"]
 urls = ["http://192.168.0.11:8086"]

 ## The target database for metrics; will be created as needed.
 database = "telegraf"

 ## If true, no CREATE DATABASE queries will be sent. Set to true when using
 ## Telegraf with a user without permissions to create databases or when the
 ## database already exists.
 skip_database_creation = true

 ## Name of existing retention policy to write to. Empty string writes to
 ## the default retention policy. Only takes effect when using HTTP.
 # retention_policy = ""

 ## Write consistency (clusters only), can be: "any", "one", "quorum", "all".
 ## Only takes effect when using HTTP.
 # write_consistency = "any"

 ## Timeout for HTTP messages.
 # timeout = "5s"

 ## HTTP Basic Auth
 username = "telegraf"
 password = "MYPASSWORD"

Además, vamos a añadir métricas de CPU y Disco. Para ello, como siempre, descomentamos los bloques correspondientes:

[[inputs.cpu]]
[[inputs.disk]]

Guardamos el fichero y al ejecutar telegraf.exe podremos ver como se ejecuta, y en Chronograf tendremos los datos reportados.

1
2
3
4
5
6
7
8


2019-11-26T10:15:53Z I! Starting Telegraf 1.12.6
2019-11-26T10:15:53Z I! Using config file: C:\Program Files\Telegraf\telegraf.conf
2019-11-26T10:15:53Z I! Loaded inputs: win_perf_counters
2019-11-26T10:15:53Z I! Loaded aggregators:
2019-11-26T10:15:53Z I! Loaded processors:
2019-11-26T10:15:53Z I! Loaded outputs: influxdb
2019-11-26T10:15:53Z I! Tags enabled: host=HCESO5CG54924LC
2019-11-26T10:15:53Z I! [agent] Config: Interval:10s, Quiet:false, Hostname:"PCWINDOWS", Flush Interval:10s

En caso de que hayamos metido Telegraf en otra ruta, o queramos simplemente testear su ejecucion, podemos lanzar el siguiente comando adecuando las rutas a las correctas:

1

C:\"Program Files"\Telegraf\telegraf.exe --config C:\"Program Files"\Telegraf\telegraf.conf --test

Registar como servicio

En Windows la ejecución de Telegraf es de forma manual. Pero podemos registrarlo como servicio para que levante automáticamente, que es el comportamiento lógico.

Abrimos una consola de comandos, o Powershell, con privilegios de Administrador, y ejecutamos lo siguiente:

1

C:\"Program Files"\Telegraf\telegraf.exe --service install

Para levantar el servicio, ejecutamos:

1

net start telegraf

Con esto ya tendríamos la monitorización de nuestro equipo Windows lista para ser consumida.

Dashboard Grafana

Lógicamente, las métricas que recoge desde Windows no son las mismas que hemos visto de nuestra Raspberry, por lo que necesitamos visualizarlas desde otro dashboard diferente.

Para hacerlo de forma más fácil, podemos utilizar el dashboard compartido por el usuario David Stephens. Ya hemos visto anteriormente tambien la forma de importar estos dashboards

https://grafana.com/grafana/dashboards/1902

Monitorización con Telegraf, InfluxDB y Grafana

Sat, 16 Nov 2019 00:00:00 +0000

Uno de los usos más prácticos que se le pueden dar a nuestra Raspberry, es utlizarlo como un servidor central para monitorizar los diferentes equipos de nuestra casa.

Una forma sencilla, muy potente y con uso de consumos mínimo, muy utilizado en entornos productivos, es:

Telegraf – es el «cliente» que recolecta los datos en su host, y los envía una una Base de Datos centralizada. Es ampliamente customizable mediante plugins.
InfluxDB – Es la BBDD que recibe los datos de Telegraf. Está diseñado para trabajar de forma muy eficiente con series de datos temporales.
Grafana – Es el frontend donde visualizaremos los diferentes gráficos y medidores. Recolecta datos de muchísimas otras fuentes por lo que es muy elastico de cara a futuro.

Todos estos productos son Open Source y gratuitos, y activamente desarrollados.

Un diagrama básico podría ser el siguiente:

En mi caso lo voy a instalar todo en una raspberryPi 2B corriendo Raspbian Buster. Más adelante veremos como añadimos más nodos.

Antes de nada necesitamos tener clara la versión y codigo de nuestro S.O., en nuestro caso buster

1
2
3
4
5
6


pi@rpi2:~ $ lsb_release -a
No LSB modules are available.
Distributor ID: Raspbian
Description: Raspbian GNU/Linux 10 (buster)
Release: 10
Codename: buster

Instalación de InfluxDB y Telegraf

Añadimos los repositorios de influx, son el mismo para ambos productos.

1
2


curl -sL https://repos.influxdata.com/influxdb.key | sudo apt-key add -
echo "deb https://repos.influxdata.com/debian buster stable" | sudo tee /etc/apt/sources.list.d/influxdb.list

Instalamos Telegraf y InfluxDB

1
2
3


sudo apt update
sudo apt install telegraf
sudo apt install influxdb

Configurar Telegraf

Antes de nada, debemos de configurar Telegraf para indicarle qué información debe recoger, y dónde debe enviarla. Para ello modificamos el fichero de configuración

1

sudo nano /etc/telegraf/telegraf.conf

En la sección [[outputs.influxdb]] descomentamos la url correspondiente a http.

1

 urls = ["http://127.0.0.1:8086"]

el nombre del database a utilizar

1

database = "telegraf"

y le indicamos que no cree la BBDD, ya que la vamos a crear manualmente nosotros más delante

1

 skip_database_creation = true

También dentro de este apartado, vamos a añadir autentificación para tener más controlado el entorno, y no dejar los datos expuestos a cualquier ataque. Se pueden añadir medidas adicionales, pero como primer paso nos puede servir con esto.

1
2
3


 ## HTTP Basic Auth
 username = "telegraf"
 password = "MIPASSWORD"

Reinicamos el servicio para que coja los cambios realizados:

1

sudo systemctl restart telegraf

y lo activamos como servicio para que levante automáticamente

1

sudo systemctl enable telegraf

InfluxDB

Los puertos que utiiliza InfluxDB por defecto son:

Puerto	Descripcion
8086	API http a la que se conectará Telegraf
8088	Servicio de backup y restore

Vamos a configurar la autentificación, al igual que hicimos con Telegraf. Para ello modificamos el fichero de configuracion de InfluxDB:

1

sudo nano /etc/influxdb/influxdb.conf

Y modificamos lo siguiente dentro del apartado [http]

1
2
3


 enabled = true
 bind-address = ":8086"
 auth-enabled = true

Tras esto, guardamos y reiniciamos el servicio

1

sudo systemctl restart influxdb

Y lo activamos como servicio para que levante automáticamente:

1

sudo systemctl enable influxdb

Chronograf

Los puertos que utiiliza Cronograf por defecto son:

Puerto	Descripcion
8088	API http a la consola de administración

Para poder ver, o gestionar influxdb de forma gráfica, podemos instalar Chronograf

1

sudo apt install chronograf

Creamos también el usuario admin de nuestro InfluxDB

1

curl -XPOST "http://localhost:8086/query" --data-urlencode "q=CREATE USER admin WITH PASSWORD 'MIPASSWORD' WITH ALL PRIVILEGES"

Ahora ya podemos acceder a la GUI o consola de administración. Lo podemos hacer en local (http://localhost:8888) o remotamente accediendo a la IP de nuestra raspberryPI (http://192.168.0.X:8888)

Una vez abierto, iniciamos una conexión añadiendo los datos de nuestro InfluxDB, y el usuario admin que acabamos de crear

Una vez creado, nos vamos a «InfluxDB Admin»

Creamos una nueva BBDD:

y un usuario telegraf con todos los permisos

Con esto debería estar todo listo. Hacemos un reboot para comprobar que todo arranca bien, y Telegraf empieza a meter datos en la BBDD

Lo podemos ver en Chronograf, en la opcion «Explore»

Con esto ya podemos ver de forma sencilla los datos reportados por Telegraf. En el siguiente capítulo veremos como ver esto de una manera más avanzada utilizando Grafana.

Python 11 – Funciones

Tue, 21 May 2019 00:00:00 +0000

A grandes rasgos, una función es una «porción» del código, a la que pasamos algo, lo procesa, y nos puede o no devolver el resultado.

Hay que tener en cuenta que las funciones nunca se van a ejecutar por sí solas. Es decir, debemos llamar a la propia función desde otra parte del código para que se ejecute y se procese.

Aunque esto puede parece algo nuevo, ya hemos estado utiilzando funciones preconstruidas, como por ejemplo

print()
dir()
type()

Vamos a definir una funcion muy simple. Se utiliza «def» para definir una función:

1
2


def hola():
 print ("Hola, soy una función")

Con la función definida sin más, no se va a ejecutar nada, por lo que debemos llamarla para que se procese.

1
2
3
4
5
6
7
8


# Defino la función
def hola():
 print ("Hola, soy una función")

# llamo a la funcion 
hola()
PS C:> python.exe .\funcion.py
Hola, soy una función

A las funciones se les puede pasar parámetros. Reutilizando el ejemplo anterior, vamos a pasarle un string para que lo procese e imprima.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# Defino la función
def hola(parametro):
 print ("Hola, soy una función. Me has pasado:" + parametro)

# llamo a la funcion 
hola("UNO")
hola("Otro test")
PS C:> python.exe .\funcion.py
Hola, soy una función. Me has pasado:UNO
Hola, soy una función. Me has pasado:Otro test

Lógicamente, en las funciones se pueden utilizar otras funciones, cualquier tipo de lógica, etc.

Cuando en una función definimos un parámetro, este se hace «mandatory«, es decir, que si llamamos a la función sin pasar un parámetro, nos va a mostrar un error.

Para solucionar esto, podemos definir un valor por defecto a la hora de definir la función, de forma que si se llama sin un valor, este coja el definido por defecto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# Defino la función
def hola(parametro="vacio"):
 print ("Hola, soy una función. Me has pasado:" + parametro)

# llamo a la funcion 
hola()
hola("Otro test")
PS C:> python.exe .\funcion.py
Hola, soy una función. Me has pasado:vacio
Hola, soy una función. Me has pasado:Otro test

return

Para que la función nos devuelve un parámetro, utilizarmos return. En ese ejemplo vamos a crear una función para sumar dos números que pasemos como parámetros. Utilizamos también print() para imprimir el resultado, ya que sino el valor devuelto únicamente quedaría alojado en memoria y no se mostraría en pantalla.

1
2
3
4
5
6
7
8


# Defino la función
def sumar(num1, num2):
 return num1 + num2

# llamo a la funcion, y imprimo el resultado
print(sumar(20,5))
PS C:> python.exe .\funcion.py
25

Python 12 – Módulos

Tue, 21 May 2019 00:00:00 +0000

A grandes rasgos, se puede entender como que son programas que forman parte de otro programa mayor. Se utilizan para poder reutilizar partes de código que ya están desarrolladas y funcionando.

Podemos diferenciar 3 grandes tipos:

módulos de python preconstruidos

proporcionados por el propio lenguaje Python y accesibles directamente

módulos de terceros

desarrollados por la comunidad. pueden ser descargados desde internet o fuentes de terceros directamente

módulos propios

estos son los que desarrollamos por nosotros mismos

módulos python

Se puede ver una lista de los módulos disponibles en:

https://docs.python.org/3/py-modindex.html

para importar un módulos utilizamos la palabra clave import, y después el nombre del modulo.

1

import tokenize

Es importante conocer la documentación del módulo antes de poder utilizarlo, para saber su funcionamiento y forma de usarlo.

Vamos a utilizar el módulo datetime como ejemplo: https://docs.python.org/3.7/library/datetime.html

lo importamos, y utilizamos la función date.today del propio módulo, lo cual nos devuelve la fecha actual:

1
2
3
4


import datetime
print(datetime.date.today())
PS C:> python.exe .\modulos.py
2019-05-23

Otro ejemplo utilizando timedelta(), al cual le pasamos 3700 segundos, y nos lo transforma en tiempo «humano» 1h 1min 40 seg.

1
2
3
4


import datetime
print(datetime.timedelta(seconds=3700))
PS C:> python.exe .\modulos.py
1:01:40

Podemos especificar qué modulo concreto queremos importar con from x import x, en lugar de importar todo el módulo. Hay que prestar atención a la forma de llamarlo si utilizamos este método.

1
2


from datetime import timedelta
print(timedelta(seconds=3700))

modulos propios

vamos a crear un módulo propio que se va a llamar mod_operaciones.py, en el que vamos a definir una serie de funciones que nos permita efectuar operaciones con números:

Para ello, creamos un nuevo fichero llamado mod_operaciones.py dentro de la ruta de nuestro programa, y con el siguiente contenido

1
2
3
4
5


def suma (n1, n2):
 print (n1 + n2)

def resta (n1, n2):
 print (n1 - n2)

en el fichero anterior, modulos.py, vamos a importar este módulo y llamar a la función de suma. Le pasamos como valores 3 y 5:

1
2
3
4


import mod_operaciones
mod_operaciones.suma(3,5)
PS C:> python.exe .\modulos.py
8

modulos de terceros

Se pueden ver módulos de terceros que podemos reutilizar, en el siguiente enlace:

https://pypi.org/

Estos módulos pueden descargarse e instalarse directamente con la utilidad PIP

Por ejemplo, vamos a instalar el módulo bloodyterminal: https://pypi.org/project/bloodyterminal/

es tan simple como lanzar el siguiente comando en la terminal: pip install bloodyterminal

1
2
3
4
5
6
7


PS C:> pip install bloodyterminal
 Collecting bloodyterminal
 Downloading https://files.pythonhosted.org/packages/14/d1/9cbc37ba8e6edbe1e9004f94a7301b4a70694d2b90e045be2cd836fd4362/bloodyterminal-4.0.tar.gz
 Requirement already satisfied: colorama in c:\users\50034411\appdata\roaming\python\python37\site-packages (from bloodyterminal) (0.4.1)
 Installing collected packages: bloodyterminal
 Running setup.py install for bloodyterminal … done
 Successfully installed bloodyterminal-4.0

Con esto, el módulo ya queda disponible para que podamos utilizarlo

1
2
3
4


from bloodyterminal import btext
btext.success("Esto es un texto formateado como success")
PS C:> python.exe .\modulos.py
[SUCCESS] Esto es un texto formateado como success

Python 10 – Bucles (For / While)

Mon, 20 May 2019 00:00:00 +0000

Son tipos de estructuras de control de flujo, que funcionan de forma diferente a los if / else. En este caso, se indica un loop, bucle, o repetición que durará mientras se cumpla determinada condición.

for

For se utiliza para recorrer todos los elementos de una lista, de uno en uno, y ejecutar acciones sobre cada uno de sus elementos.

Vamos a verlo con un ejemplo. Supongamos que tenemos una lista de colores:

1

colores = ['azul','rojo','amarillo','verde']

Si quisieramos imprimir los valores que se encuentran en cada uno de sus incides, podríamos scribirlo así:

1
2
3
4


print(colores[0])
print(colores[1])
print(colores[2])
print(colores[3])

Si añadieramos otro elemento más a la lista, tendríamos que definir una nueva sentencia print() con su nuevo índice para que se imprima.

Esto podríamos hacerlo de manera mucho más simple y controlada utilizando for:

1
2
3
4
5
6
7
8


colores = ['azul','rojo','amarillo','verde']
for color in colores:
 print(color)
PS C:> python .\bucles.py
azul
rojo
amarillo
verde

Esto significaría: para cada elemento (que vamos a llamar color), de la lista colores, haz un print() del elemento.

Lógicamente, dentro de for se puede utilizar otro tipo de estructuras según nuestras necesidades. Por ejemplo, podemos parar el programa cuando el color sea amarillo.

1
2
3
4
5
6
7
8


colores = ['azul','rojo','amarillo','verde']
for color in colores:
 if color == 'amarillo':
 break
 print(color)
PS C:> python .\bucles.py
azul
rojo 

Otro ejemplo de for. Vamos a imprimir un rango de números, del 1 al 5, ayudándonos del constructor range()

1
2
3
4
5
6
7


for num in range(1, 5):
 print(num)
PS C:> python .\bucles.py
1
2
3
4 

for también funciona con los difererentes caracteres de un string, por ejemplo:

1
2
3
4
5
6
7
8
9


for letra in "Python":
 print(letra)
PS C:> python .\bucles.py
P
y
t
h
o
n

while

Es un loop algo parecido a for, aunque en este caso se recorren los elementos MIENTRAS la condición dada sea cierta. Se podría ver como un for condicional. Hay que tener cuidado con los while, ya que una vez que se ejecuta, vuelve al inicio, por lo que hay que asegurarse que tenemos algún mecanismo de control.

Así en un par de lineas parece complejo, pero como siempre, vamos a verlo con un ejemplo: Vamos a definir un número. Mientras este numero sea inferior a 10, lo imprimimos. Ya que numero es un valor fijo, el bucle se repitiría infinitamente con el mismo valor, por lo que nos aseguramos de que tras cada ejecución, el valor de numero de incremente. En el momento que el número sea 10, la condición del while ya no se cumple, por lo que se salta el bucle.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


count = 20
while count < 10:numero = 2
while numero < 10:
 print(numero)
 numero = numero +1
PS C:> python .\bucles.py
2
3
4
5
6
7
8
9 

Python 8 – Diccionarios

Sat, 18 May 2019 00:00:00 +0000

Los diccionarios son un tipo de dato que nos permite definir su contenido en base a claves y valores. Se suelen utilizar para definir objetos de la vida real (productos, objetos, personas, etc)

Se puede definir en una sóla línea, aunque es mucho más legible si lo hacemos en varias.

Los dictionarios tambien se pueden incluir dentro de listas. Como vimos , previamente, una lista puede contener elementos de cualquier tipo.

Por ejemplo, para definir artículos en una tienda:

1
2
3
4
5
6


dictio = {
 "articulo": "procesador",
 "cantidad": 1,
 "precio": 165
 "descripcion": "Procesador Ryzen 2600 a 3.4MHz"
 }

Métodos

1
2


>>> dir(dict)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

.keys

sirve para mostrar los indices del diccionario:

1
2
3
4
5
6
7
8
9


dictio = {
 "articulo": "procesador",
 "cantidad": 1,
 "precio": 165,
 "descripcion": "Procesador Ryzen 2600 a 3.4MHz"
 }
print(dictio.keys())
PS C:\> python dictio.py
 dict_keys(['articulo', 'cantidad', 'precio', 'descripcion'])

.items

Nos muestra las keys y valores de todos los elementos:

1
2
3
4
5
6
7
8
9


dictio = {
 "articulo": "procesador",
 "cantidad": 1,
 "precio": 165,
 "descripcion": "Procesador Ryzen 2600 a 3.4MHz"
 }
print(dictio.items())
PS C:\> python dictio.py
 dict_items([('articulo', 'procesador'), ('cantidad', 1), ('precio', 165), ('descripcion', 'Procesador Ryzen 2600 a 3.4MHz')])

del

Sirve para borrar al igual que lo vimos con las listas o las tuplas

.clean

Sirve para borrar al igual que lo vimos con las listas o las tuplas

Python 9 – Condicionales (If / Else / Elsif)

Sat, 18 May 2019 00:00:00 +0000

Los condicionales son mecanismos que nos van a permitir controlar el flujo del programa, ejecutando ciertas partes del código únicamente bajo ciertas condiciones que nos interesen

Operadores de comparación

Son operadores especiales que nos devuelven un booleano (True / False)

mayor >

1
2


>>> 2 > 4
False

menor <

1
2


>>> 2 < 4
True

igual ==

1
2


>>> 2 == 4
False

Tambien se puede utilizar con otros tipos de datos, como por ejemplo strings:

1
2


>>> "hola" == "hola"
True

if

Si la condición se cumple (True), se ejecuta la sentencia, si no se cumple (False), se salta el bloque if y continúa la ejecución.

Vamos a verlo en un ejemplo. Creamos una variable edad. Si la edad es menor de 65, aún no se puede jubilar:

1
2
3
4
5


edad = 20
 if edad < 65:
 print("Aun no te puedes jubilar")
PS C:> python .\condition.py
Aun no te puedes jubilar

En este punto es importante indicar que en Python se debe indentar correctamente con cierto número de espacios, o tabuladores. Así, en este caso, la expresión debe ir dentro de la declaración del if

En este caso, vamos a poner 70 como edad. En este caso, como no se cumple la condición, se salta el bloque if:

1
2
3
4
5
6


edad = 70
 if edad < 65:
 print("Aun no te puedes jubilar")
 print("He terminado")
PS C:> python .\condition.py
He terminado

if / Else

En este caso, si no se cumple la condición del if, se ejecuta la indicada en el bloque else. Importante tener en cuenta la indentación.

1
2
3
4
5
6
7
8
9


edad = 70
 if edad < 65:
 print("Aun no te puedes jubilar")
 else:
 print("Ya te puedes jubilar")
 print("He terminado")
PS C:> python .\condition.py
Ya te puedes jubilar
He terminado

Modificamos únicamente el valor de edad:

1
2
3
4
5
6
7
8
9


edad = 30
 if edad < 65:
 print("Aun no te puedes jubilar")
 else:
 print("Ya te puedes jubilar")
 print("He terminado")
PS C:> python .\condition.py
Aun no te puedes jubilar
He terminado

elif

Permite hacer otra comparación adicional de tipo «if«, antes de saltar al else. Se pueden utilizar tantos elif como sea necesario antes de else.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


edad = 18
 if edad < 65:
 print("Aun no te puedes jubilar")
 if edad == 18:
 print("Te queda mucho por cotizar") 
 else:
 print("Ya te puedes jubilar")
 print("He terminado")
PS C:> python .\condition.py
Aun no te puedes jubilar
Te queda mucho por cotizar
He terminado

Operadores lógicos

and
or
not

Los operadores lógicos son otro tipo que nos ayudan a hacer mucho más claro y rápido el código.

Podemos escribir el tipo de código que hemos estado viendo hasta ahora, utilizando operadores lógicos de forma que nos quede en una sóla línea. Mejor verlo directamente en un ejemplo….

Vamos a verificar si un número está entre 10 y 20. Podemos escribirlo como hemos visto hasta ahora:

1
2
3
4


numero = 15
 if numero > 10:
 if numero < 20:
 print ("el numero está entre 10 y 20")

o utilizando los operadores lógicos:

1
2


if numero > 10 and numero < 20:
 print ("el numero está entre 10 y 20") 

Otro ejemplo, en este caso si el número es mayor que 10, pero el número no es 20, nos muestra el mensaje

1
2
3
4


if numero > 10 and not numero == 20:
 print ("el numero es mayor que 10 pero no es 20")
PS C:> python .\condition.py
el numero es mayor que 10 pero no es 20

Python 7 – Sets

Fri, 17 May 2019 00:00:00 +0000

Es un tipo de datos similar a las listas o tuplas, pero con algunas particularidades. Son conjuntos de datos desordenados, no tienen un índice. Se identifican con {}

1
2
3
4
5
6


set = {'uno','dos','tres','cuatro'}
print(set)
print(type(set))
C:\>python set.py

{'tres', 'cuatro', 'uno', 'dos'}

Métodos

1
2
3


>>> dir(set)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
>>>

in

Verifica si existe el valor dentro del set. Su resultado es un Booleano:

1
2
3
4
5


set = {'uno','dos','tres','cuatro'}
print('dos' in set)
C:\>python set.py

True

.add

Al no tener índice, los datos son añadidos, pero no se mantiene ningún orden como sí ocurre con las listas.

1
2
3
4
5
6


set = {'uno','dos','tres','cuatro'}
set.add('Nuevo')
print(set)
C:\>python set.py

{'Nuevo', 'uno', 'tres', 'dos', 'cuatro'}

.remove

Para borrar elementos:

1
2
3
4
5
6


set = {'uno','dos','tres','cuatro'}
set.remove('tres')
print(set)
C:\>python set.py

{'dos', 'uno', 'cuatro'}

.clear

Vacía el set, eliminando todos sus elementos

1
2
3
4
5
6


set = {'uno','dos','tres','cuatro'}
set.clear()
print(set)
C:\>python set.py

set()

.del

Elimina el set por completo.

1
2
3
4


set = {'uno','dos','tres','cuatro'}
del set
print(set)
C:\>python set.py

Python 6 – Tuplas

Thu, 16 May 2019 00:00:00 +0000

Son un tipo de datos muy parecido a las listas, pero con la excepción de que las tuplas no pueden ser modificadas. Son inmutables. Se identifican por los paréntesis ()

Su ventaja es que son más rápidas, y más seguras.

1
2
3
4
5
6


tupla = (1, 2, 3)
print(tupla)
print(type(tupla))
C:\>python tuplas.py

(1, 2, 3)

Para definir una tupla, se puede hacer de forma literal: tupla = (1, 2, 3), o mediante el constructor tuple()

Al igual que en las listas, podemos acceder a cualquier elemento de una tupla

1
2
3
4
5


tupla = (10, 20, 30, 40)
print(tupla[2])
C:\>python tuplas.py

30

Métodos

1
2
3


>>> dir(tuple)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
>>>

del

Podemos borrar la tupla por completo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


tupla = (10, 20, 30, 40)
del tupla
print(tupla)
C:\>python tuplas.py

Traceback (most recent call last):

 File "tuplas.py", line 4, in 

 print(tupla)

NameError: name 'tupla' is not defined

No tiene mucho sentido extenderse con este tema, porque como ya hemos dicho previamente, es un tipo de datos muy, muy similar a las listas, con la excepción de que son inmutables.

Python 5 – Listas

Wed, 15 May 2019 00:00:00 +0000

Una lista puede contener cualquier tipo de elementos, incluso listas dentro de otras listas.

Vamos a poner un ejemplo de una lista que contenga varios tipos distintos de elementos:

un entero
un string
un float
un boleano
una lista

1

lista1 = [2, "texto", 55.7, False, [2, 4, 6]]

El constructor es una función que nos va a permitir construir una lista. En este caso, pasamos una tupla ()

1
2
3
4


lista2 = list((2, 4, 6, 8))
 print(lista2)
C:>python lists.py
[2, 4, 6, 8]

range()

Esta función nos permite generar una lista mediante un rango de datos. En este ejemplo, una lista con elementos de 1 a 10

Hay que tener en cuenta que el rango final no es incluido en la lista

1
2
3
4


lista = list(range(1,10))
 print(lista)
C:>python lists.py
[1, 2, 3, 4, 5, 6, 7, 8, 9]

igual que con los strings, podemos ver el elemento en la posición que nos interesa. Teniendo que en cuenta que se inicia el index en 0

1
2
3
4
5
6
7


lista = ["uno", "dos", "tres", "cuatro"]
print(lista)

print(lista[2])
C:>python lists.py
['uno', 'dos', 'tres', 'cuatro']
tres

in

Para saber si un elemento existe dentro de una lista:

1
2
3
4
5
6
7


lista = ["uno", "dos", "tres", "cuatro"]
print(lista)

print('dos' in lista)
C:>python lists.py
['uno', 'dos', 'tres', 'cuatro']
True

En las listas, los elementos se puede cambiar y modificar.

1
2
3
4
5
6
7
8


lista = ["uno", "dos", "tres", "cuatro"]
 print(lista)

lista[2] = 'cambiado'
 print(lista)
C:>python lists.py
['uno', 'dos', 'tres', 'cuatro']
['uno', 'dos', 'cambiado', 'cuatro']

métodos

Al igual que vimos previamente con los string, podemos ver los métodos que podemos aplicar a las listas:

1
2


dir(list)
 ['add', 'class', 'contains', 'delattr', 'delitem', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'getitem', 'gt', 'hash', 'iadd', 'imul', 'init', 'init_subclass', 'iter', 'le', 'len', 'lt', 'mul', 'ne', 'new', 'reduce', 'reduce_ex', 'repr', 'reversed', 'rmul', 'setattr', 'setitem', 'sizeof', 'str', 'subclasshook', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

.len

vemos el numero de elementos de la lista:

1
2
3
4
5
6


lista = list(range(1,10))
 print(lista)
print(len(lista))
C:>python lists.py
[1, 2, 3, 4, 5, 6, 7, 8, 9]
9

.append

añade un elemento al final de la lista

1
2
3
4
5
6
7


lista = ["uno", "dos", "tres", "cuatro"]
 print(lista)
lista.append('nuevo')
 print(lista)
C:>python lists.py
['uno', 'dos', 'tres', 'cuatro']
['uno', 'dos', 'tres', 'cuatro', 'nuevo']

.extend

Añade varios elementos al final de la lista. Se le pasan dichos elementos dentro de una lista [] o de una tupla ().

1
2
3
4
5
6
7


lista = ["uno", "dos", "tres", "cuatro"]
 print(lista)
lista.extend(['nuevo','otro'])
 print(lista)
C:>python lists.py
['uno', 'dos', 'tres', 'cuatro']
['uno', 'dos', 'tres', 'cuatro', 'nuevo', 'otro']

.insert

Inserta un nuevo elemento en la posición de indice que le indiquemos.

1
2
3
4
5
6
7


lista = ["uno", "dos", "tres", "cuatro"]
 print(lista)
lista.insert(1,'DOS')
 print(lista)
C:>python lists.py
['uno', 'dos', 'tres', 'cuatro']
['uno', 'DOS', 'dos', 'tres', 'cuatro']

.pop

Elimina un elemento del final de la lista. Si se le pasa un número de indice, elmina el elemento en esa posición.

1
2
3
4
5
6
7


lista = ["uno", "dos", "tres", "cuatro"]
 print(lista)
lista.pop()
 print(lista)
C:>python lists.py
['uno', 'dos', 'tres', 'cuatro']
['uno', 'dos', 'tres']

.remove

Elimina un elemento indicado de la lista

1
2
3
4
5
6
7


lista = ["uno", "dos", "tres", "cuatro"]
 print(lista)
lista.remove('dos')
 print(lista)
C:>python lists.py
['uno', 'dos', 'tres', 'cuatro']
['uno', 'tres', 'cuatro']

.clear

Borra todos los elementos de la lista, dejándola limpia

.sort

Ordena los elementos de la lista

1
2
3
4
5
6
7


lista = ["uno", "dos", "tres", "cuatro"]
 print(lista)
lista.sort()
 print(lista)
C:>python lists.py
['uno', 'dos', 'tres', 'cuatro']
['cuatro', 'dos', 'tres', 'uno']

Se puede utilizar la propiedad reserse para ordenar los elementos al revés:

1

lista.sort(reverse=True)

.count

Cuenta los elementos que hay en la lista.

1
2
3
4
5
6


lista = ["uno", "dos", "tres", "cuatro"]
 print(lista)
print(lista.count('tres'))
C:>python lists.py
['uno', 'dos', 'tres', 'cuatro']
1

Python 4 – Numeros

Tue, 14 May 2019 00:00:00 +0000

En esta entrada vamos a ir profundizando más en Python despacito pero de forma firme, y vamos a conocer un poco más a fondo el tipo de datos numérico.

Como siempre para ver qué tipo de dato es, podemos utilizar type()

1
2
3
4
5
6
7
8


print(type(134))

C:\>python numbers.py
<class 'int'>
print(type(134.67))

C:\>python numbers.py
<class 'float'>

Si se realizan operaciones entre enteros, el resultado es un entero

Si se realizan operaciones entre enteros y un float, el resultado es un float

operadores

sumar +

1
2


>>> 2 + 2
4

restar -

1
2


>>> 6 - 1
5

multiplicar *

1
2


>>> 3 * 2
6

dividir /

1
2


>>> 10/3
3.3333333333333335

Elevar (exponente) **

1
2


>>> 2**4
16

Esto es lo mismo que escribir:

1
2


>>> 2 * 2 * 2 * 2
16

División entera. // Devuelve el valor entero de la división

1
2


>>> 10//3
3

Módulo %. Devuelve el resto que sobra de la division entera

1
2


>>> 10 % 3
1

Precedencia

Los operadores se resuelven con este orden de prioridad:

Paréntesis
exponentes
multiplicaciones
divisiones
porcentajes
sumas
restas

Python 3 – Strings

Mon, 13 May 2019 00:00:00 +0000

La función dir() nos muestra lo que podemos hacer con el dato pasado como parámetro. Esto se conoce como métodos. Por ejemplo:

dir(mi_string) en consola de Python, o print(dir(mi_string)) en un script

1
2
3


C:\>python strings.py

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

Métodos

.upper

Para utilizar el mótodo «.upper«, el cual nos pasaría el texto a mayúsculas, lo invocaríamos de la siguiente forma:

1
2
3


print(mi_string.upper())
C:>python strings.py
SOY UN STRING

.swapcase

otro ejemplo de método es «.swapcase«, el cual nos intercambia mayúsculas y minúsculas

1
2
3
4
5
6


print(mi_string)

print(mi_string.swapcase())
C:>python strings.py
Soy Un String
sOY uN sTRING

.replace

Otro método útil es «.replace«, para remplazar un patrón por otro. Por ejemplo:

1
2
3
4


print(mi_string.replace('Un','Otro'))
C:\Users\50034411\Documents\python-course>python strings.py
Soy Un String
Soy Otro String

Podemos utilizar también métodos encadenados, En el siguiente ejemplo utilizamos el método «.replace«, y el resultado lo pasamos a «.swapcase» ejemplo:

1
2
3
4


print(mi_string.replace('Un','Otro').swapcase())
C:>python strings.py
Soy Un String
sOY oTRO sTRING

.count

Para contar podemos utilizar el método «.count«. Esto se puede utilizar para caracteres, conjuntos de ellos, vacíos, etc. Por ejemplo vamos a contar las veces que se repite el carácter «n» en mi_string

1
2
3
4


print(mi_string.count('n'))
C:>python strings.py
Soy Un String
2

.startswith .endswith

Para saber si un string comienza por cierto carácter o string, se utilizar el método «.startswith«. Esto nos devuelve un booleano (true / false). Si inversa sería «.endswith«

1
2
3
4


print(mi_string.startswith('Soy'))
C:>python strings.py
Soy Un String
True

.split

Para dividir un string en otros, se utiliza «.split«. Por defecto utiliza el espacio en blanco para delimitar los substrings. Se genera una lista [] con los strings separados.

1
2
3
4


print(mi_string.split())
C:>python strings.py
Soy Un String
['Soy', 'Un', 'String']

Podemos indicar el carácter de separación que nos interese, por ejemplo en las «n»

1
2
3
4


print(mi_string.split('n'))
C:>python strings.py
Soy Un String
['Soy U', ' Stri', 'g']

.find

Para encontrar la posición (índice) de un carácter se utiliza el método «.find«. En el siguiente ejemplo vemos cómo el carácter «U» se encuentra en la posición 4, empezando a contar desde 0

1
2
3
4


print(mi_string.find('U'))
C:\Users\50034411\Documents\python-course>python strings.py
Soy Un String
4

De forma inversa, se puede extraer el caracter de cierto índice concreto. Por ejemplo, utilizando el ejemplo anterior, vamos a mostrar el carácter que está en el index 4:

1
2
3
4


print(mi_string[4])
C:\Users\50034411\Documents\python-course>python strings.py
Soy Un String
U

Si utilizamos un valor negativo, python interpreta que deseamos comenzar a contar desde el final del string.

len()

Para saber la longitud de un string se puede utilizar la función «len«

1

 print(len(mi_string))

C:>python strings.py Soy Un String 13

.isnumeric .isalpha .isalnum

Podemos verificar si un string es númerico, alfabético o alfanumérico con los métodos «.isnumeric«, «.isalpha«, «.isalnum«, etc. Es resultado es un booleano.

1
2
3
4


print(mi_string.isnumeric())
C:\Users\50034411\Documents\python-course>python strings.py
Soy Un String
False

Formato de salida

A la hora de utilizar print(), podemos pasar variables, o string predefinidos. Para concatenar se utiliza el simbolo +

1
2
3
4


print("El string es: " + mi_string)
C:>python strings.py
Soy Un String
El string es: Soy Un String

Otra opción es incluir directamente la variable utilizando {}. Para ello es necesario indicar que se va a pasar la variable con el símbolo «f» justo al comienzo del print. Esta opción solo es válida en la versión 3.7

1
2
3
4


print(f"El string es: {mi_string}")
C:>python strings.py
Soy Un String
El string es: Soy Un String

Una tercera opción con format:

1
2
3
4


print("El string es: {0}".format(mi_string))
C:>python strings.py
Soy Un String
El string es: Soy Un String

Python 2 – Variables

Sun, 12 May 2019 00:00:00 +0000

Las variables son espacios de memoria que utilizamos para almacenar diferentes tipo de datos, y trabajar con ellos.

1
2


name = "esto es un nombre"
print(name)

nombres válidos de variables

Python es «Case Sensitive», es decir, se diferencia entre mayúsculas y minúsculas, por lo que «Nombre» es diferente de «nombre«, y diferente también de «noMBre«
El nombre de variables no puede empezar por un número

Las formas más extendidas y utilizadas de dar formato al nombre de variables extensas son:

Snake Case

Separa las palabras con guiones bajos

1

 soy_una_variable

Camel Case

La segunda y siguientes palabras comienzan con mayuscula

1

 soyUnaVariable

Pascal Case

La primera letra de cada palabra es mayúscula.

1

SoyUnaVariable

Si una variable se va a utilizar como un valor constante, se suele poner todo el nombre en mayúsculas

1

PI = 3.141618

Para definir una variable, se puede hacer de una en una

1
2


 numero = 20
 texto = "soy un texto"

o varias de forma simultánea

1

numero, texto = 25, "otro texto"

Cambiar Rom MIUI Por LineageOS

Sat, 11 May 2019 00:00:00 +0000

Vamos a explicar de forma clara y concisa como cambiar la rom stock de cualquier Xiaomi por la rom de LineageOS. En este caso vamos a utilizar un Mi8 como ejemplo.

Antes de nada, vamos a necesitar descargar varias cosas:

Mi Unlock App: https://en.miui.com/unlock/
Minimal ADB and Fastboot: https://forum.xda-developers.com/showthread.php?t=2317790
TWRP (para nuestro movil): https://dl.twrp.me/dipper/
Rom Lineage (en este caso para Mi8 dipper): https://download.lineageos.org/dipper
Gapps: https://opengapps.org/

Con todo esto ya descargado, vamos a ponernos manos a la obra.

Drivers ADB

Esto es lo más sencillo, se trata de instalar el paquete Minimal ADB and Fastboot que descargamos previamente. Tan solo hay que ejecutarlo y ir aceptando todo. En unos pocos segundos tendremos los drivers necesarios instalados en nuestro PC.

Importante, es necesario Windows 10 64 bit para el siguiente paso. El proceso puede realizarse también bajo Linux, pero en este post nos vamos a centrar en Windows.

Desbloquear el teléfono

En los teléfonos Xiaomi, por defecto viene el bootloader bloqueado, por lo que es necesario realizar el proceso oficial para liberarlo. Esto puede tardar desde unos días, a incluso un mes.

El primer paso es ir a «Ajustes» > «Sobre el teléfono» > y pulsar 7 veces sobre «Versión MIUI», hasta que se activen las opciones de desarrollador.

Ahora vamos a «Ajustes» > «Ajustes adicionales» > «Opciones de desarrollador».

Aquí debemos activar «USB Debuging», y pulsar sobre «OEM Unlock».

Con esto vamos a «Ajustes» > «Ajustes adicionales» > «Opciones de desarrollador» > «Mi Unlock Status» y nos pedirá que añadamos nuestra cuenta Xiaomi para linkar el teléfono a nuestra cuenta.

Con esto ya tenemos todo listo. Podemos apagar el teléfono e iniciarlo en modo bootloader (Volume Down + Power) y conectarlo por USB al pc.

Ahora abrimos «Mi unlock app» y vamos siguiendo los pasos. Si es nuestra primera vez, el unlock quedará solicitado y nos mostrará una cuenta atrás en horas hasta que sea efectivo. Cuando esta cuenta atrás llegue a cero, podremos repetir el proceso y esta vez sí el teléfono quedará desbloqueado.

Recovery

Llega la hora de decir adión al recovery de Xiaomi, y meter TWRP, un recovery personalizado con el que podremos tocar el móvil a nuestro antojo.

Para ello conectamos el teléfono al pc en modo bootloader (Volume Down + Power), y nos abrimos una consola de comandos en la ruta donde tenemos el fichero de TWRP descargado.

Lanzamos los siguientes comandos para flashearlo:

1
2
3


fastboot flash recovery twrp.img

fastboot reboot

Este último comando reinicia el móvil. Para que el recovery se mantenga, es necesario que mientras se reinicia dejemos pulsado Volume Up. De esta forma forzamos a que se cargue el nuevo recovery, y se haga permanente.

Ahora podemos ir a

Preparar el storage

Para eliminar el cifrado de nuestra partición de datos, y dejar todo listo para la llegada de la nueva rom, es necesario formatear el storage. Para ello seguimos los siguientes pasos:

Arrancamos en modo Recovery (Volume Up + Power)
Accedemos a «Wipe»
Pulsamos en «Format Data», y tecleamos «yes» cuando lo pida
Volvemos atrás
Pulsamos en «Reboot», y despues en «Recovery»
Hacemos swype y el movil volverá a entrar en modo recovery, listo para nuestra nueva rom

Flashear rom + gapps

Podemos flashear la rom de dos formas distintas:

Pasando la rom y gapps a la memoria interna del telefono y flashear desde recovery
Flasheando directamente desde el PC con fastboot.

La primera opción no tiene mucho misterio. Simplemente copiamos a la memoria interna del teléfono ambos archivos (rom lineageos, y gapps). Una vez copiadas, en el recovery nos vamos al botón de instalar e instalamos la rom primero, y luego las gapss. Si nos pide hacer un wipe de caché, aceptamos, y reiniciamos.

Para instalar por fastboot, en el recovery vamos a «Advanced» y activamos «Sideload».

En nuestro PC debemos abrir una consola de comandos en la carpeta donde tengamos ambos ficheros y lanzar los siguientes comandos (cambiando el nombre de los .zip por los reales de la rom y gapps)

1
2
3
4
5


adb sideload fichero_de_la_rom.zip

adb sideload fichero_de_gapps.zip

fastboot reboot

Tras esto, el móvil se reiniciará, y tras varios minutos (puede llegar a tardar incluso 20 minutos la primera vez), arrancará con LineageOS en todo su esplendor.

Python 1 – Tipos De Datos

Sat, 11 May 2019 00:00:00 +0000

En este post vamos a echar un vistazo general a los diferentes tipos de datos que podemos utilizar en el lenguaje de programación Python, y la forma de diferenciarlos.

Strings

Los datos de tipo string, se componen de Cadenas de caracteres alfanuméricos, o texto sin más. Sus elementos son tratados puramente como texto, aunque sean caracteres numéricos.

Se pueden definir entre:

Comillas simples (‘)
Comillas dobles («)
Triple comilla simple (‘ ‘ ‘)
Triple comilla doble (» » «)

1
2
3
4


print("Esto es un texto")
print('Esto es un texto')
print('''Esto es un texto''')
print("""Esto es un texto""")

Integer

Los datos de tipo Integer son Números enteros, o int

1
2


print(50)
print(559545230)

Float

Los datos de tipo Float son Números decimales o de punto flotante

1
2


print(25.77)
print(15456454564.21222)

Boolean

Son Operadores lógicos de verdadero o falso

1
2
3


True

False

Lists

Listas de elementos que pueden ser modificadas más adelante. También se puede definir una lista vacía. Pueden tener enteros, float, string… o diferentes tipos de datos dentro de una misma lista.

1
2
3


[2, 4, 6, 8, 10, 12]
['Hola','Que tal','Adios']
[]

Tuples

Similar a las listas, aunque las tuplas no pueden ser modificadas. Son inmutables

1
2


(2, 4, 6, 8, 10, 12)
()

Dictionaries

Es una serie de valores que pertenecen a una misma entidad, referenciados mediante una clave principal, o key

1
2
3
4
5


{
 "name":"Raul",
 "apellido":"Diez",
 "nick":"kether"
}

Null

Un valor de tipo nulo o sin definir aún.

Python - Iniciación al lenguaje

Fri, 10 May 2019 00:00:00 +0000

Python: Iniciación al lenguaje

Python es un lenguaje de programación de propósito general muy poderoso. Al no tener un propósito definido, se trata de un lenguaje muy flexible, y a su vez es muy sencillo y fácil de aprender e interpretar.

Todo esto hace que Python cada vez sea más popular, y más usado en todo tipo de entornos y situaciones.

Se trata de un lenguaje de alto nivel, interpretado, y multiplataforma.

Su origen data de finales de los 80, cuando fué creado por Guido van Rossum en los Paises Bajos. El nombre del lenguaje proviene de la afición de su creador por los humoristas británicos Monty Python

Toma características de lenguajes predecesores, incluso, compatibilizando la solución de varios de ellos. Por ejemplo, habilita tres formas de imprimir el valor de una variable: desde el entorno interactivo escribiendo su nombre (como en Basic), usando la función print, con concatenación de elementos (al estilo del write de Pascal) o bien con patrones de formato (al estilo del printf de C)

Las propias funcionalidades de Python se ven exponencialmente multiplicadas en PyPI (Python Package Index) donde se albergan miles de módulos de terceros para Python

Filosofía Python

También se le conoce como Zen Python. Se trata de 20 principios que influyen en el diseño del Lenguaje de Programación Python, de los cuales 19 fueron escritos por Tim Peters en junio de 1999. El texto es distribuido como dominio público:

Bello es mejor que feo. Explícito es mejor que implícito. Simple es mejor que complejo. Complejo es mejor que complicado. Plano es mejor que anidado. Disperso es mejor que denso. La legibilidad cuenta. Los casos especiales no son tan especiales como para quebrantar las reglas. Lo práctico gana a lo puro. Los errores nunca deberían dejarse pasar silenciosamente. A menos que hayan sido silenciados explícitamente. Frente a la ambigüedad, rechaza la tentación de adivinar. Debería haber una -y preferiblemente sólo una- manera obvia de hacerlo. Aunque esa manera puede no ser obvia al principio a menos que usted sea holandés. Ahora es mejor que nunca. Aunque nunca es a menudo mejor que ya mismo. Si la implementación es difícil de explicar, es una mala idea. Si la implementación es fácil de explicar, puede que sea una buena idea. Los espacios de nombres (namespaces) son una gran idea ¡Hagamos más de esas cosas!

Secciones del curso

Iremos publicando un pequeño curso de iniciación a lo largo de varios Post. Espero que los disfrutéis y os sirvan de ayuda para iniciaros en este lenguaje.

Parte 1 – Tipos de datos
Parte 2 – Variables
Parte 3 – Strings
Parte 4 – Números
Parte 5 – Listas
Parte 6 – Tuplas
Parte 7 – Sets
Parte 8 – Diccionarios
Parte 9 – Condicionales (if / else / elsif)
Parte 10 – Bucles (for / while)
Parte 11 – Funciones
Parte 12 – Módulos

Introducción a Perl - 4

Sun, 05 May 2019 00:00:00 +0000

Introducción a Perl - 4

if

Se usa para declarar condicionales, las cuales se utilizan para comprobar si una condición dada se cumple o no. En caso de que se cumpla, se continúa leyendo y ejecutando el script. Si no se cumple la condición, se salta el bloque.

Se puede interpretar como: «Si esto se cumple, haz esto«

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


print "Dime un numero mayor que 0: ";
$respuesta = <>;
if ($respuesta <= 0)
 {
 print "el numero es igual o menor que 0.";
 exit;
 }
print "Has indicado el numero $respuesta";
c:\Temp>perl perl.pl
Dime un numero mayor que 0: 4
Has indicado el numero 4

c:\Temp>perl perl.pl
Dime un numero mayor que 0: 0
el numero es igual o menor que 0.
c:\Temp>

if y else

Se puede interpretar como: «Si esto se cumple, haz esto. Si no se cumple, haz esto otro»

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


print "Dime un numero mayor que 0: ";
$respuesta = <>;
if ($respuesta <= 0)
 {
 print "ERROR: el numero es igual o menor que 0.\n";
 exit;
 }
else
 {
 print "OK: el numero es mayor que 0.\n";
 } 
print "Has indicado el numero $respuesta";
c:\Temp>perl perl.pl
Dime un numero mayor que 0: 0
ERROR: el numero es igual o menor que 0.

c:\Temp>perl perl.pl
Dime un numero mayor que 0: 6
OK: el numero es mayor que 0.
Has indicado el numero 6

if, else y elsif

Se puede interpretar como: «Si esto se cumple, haz esto. Si no se cumple pero se cumple esto, haz esto. Si tampoco se cumple, haz esto.»

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


print "Dime un numero entre 0 y 50: ";
$respuesta = <>;
if ($respuesta <= 0)
 {
 print "ERROR: el numero es igual o menor que 0.\n";
 exit;
 }
elsif ($respuesta > 50)
 {
 print "ERROR: el numero es mayor de 50.\n";
 }
else
 {
 print "OK: el numero es mayor que 0 y menor que 50.\n";
 } 
print "Has indicado el numero $respuesta";
c:\Temp>perl perl.pl
Dime un numero entre 0 y 50: 0
ERROR: el numero es igual o menor que 0.

c:\Temp>
c:\Temp>
c:\Temp>
c:\Temp>perl perl.pl
Dime un numero entre 0 y 50: 55
ERROR: el numero es mayor de 50.
Has indicado el numero 55

c:\Temp>
c:\Temp>
c:\Temp>perl perl.pl
Dime un numero entre 0 y 50: 15
OK: el numero es mayor que 0 y menor que 50.
Has indicado el numero 15

for

Se puede utilizar tanto for (estilo C), como foreach, ya que son sinónimos.

El bucle for tiene 3 partes en la sección de control:

Initialize
Test
Step

1
2
3


 for (INITIALIZE; TEST; STEP) {
 BODY;
 }

Por ejemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


 for (my $i=0; $i <= 9; $i++) {
 print "$i\n";
 }
c:\Temp>perl perl.pl
0
1
2
3
4
5
6
7
8
9

c:\Temp>

Respecto al bucle foreach, se definiría de la siguiente forma:

1
2
3


 foreach my $i (0..9) {
 print "$i\n";
 }

Se puede hacer un bucle infinito así:

1
2
3


 for (;;) {
 # hacer algo
 }

Aunque es más normal utilizar while

1

while (1) { # hacer algo}

while

El bucle while es algo similar a for, pero en este caso se ejecuta mientras la condición sea verdadera.

1
2
3
4
5
6
7


my $counter = 0;
 
while ($counter < 20) {
 print "$counter\n";
 $counter += 2;
}
print 'done';

Introducción a Perl - 3

Thu, 21 Mar 2019 00:00:00 +0000

Introducción a Perl - 3

Matrices o Arrays

Los Arrays son básicamente un conjunto de datos almacenados en una sola variable. A diferencia de las escalares, donde se almacena un único valor, los Arrays o Matrices contienen muchos valores diferentes. Tanto es así, que dentro de un Array se pueden almacenar tanto Escalares como otros Arrays (pero esto lo dejaremos para más adelante)

Las variables de tipo Array se identifican con el símbolo: «@«

Un ejemplo:

1

@semana_laboral = ("Lunes","Martes","Miercoles","Jueves","Viernes");

Los elementos en una matriz se comienzan a numerar desde 0. Para referenciarnos a un único valor de la matriz, lo llamamos utlizando el simbolo de Escalar ($) y el número de su índice. Por lo tanto los elementos de nuestra matriz de ejemplo serían:

1
2
3
4
5


$semana_laboral[0] = "Lunes";
$semana_laboral[1] = "Martes";
$semana_laboral[2] = "Miercoles";
$semana_laboral[3] = "Jueves";
$semana_laboral[4] = "Viernes";

Para saber el número de elementos que tiene una matriz, lo podemos hacer de la siguiente forma:

1
2
3
4
5
6
7
8


@semana_laboral = ("Lunes","Martes","Miercoles","Jueves","Viernes");
$elementos = @semana_laboral;
print "Numero de elemento: $elementos\n";

-----------------------

c:\Temp>perl hello.pl
Numero de elemento: 5

Operaciones con Matrices

Para ver esto de forma rápida, vamos a poner unos ejemplos rápidos sobre el uso de casa operación, utilizando nuestro Array de ejemplo:

Reverse (invertir la matriz)

1
2
3
4
5
6


@semana_laboral = ("Lunes","Martes","Miercoles","Jueves","Viernes");
@semana_modificada = reverse (@semana_laboral);
print "Nueva Array: @semana_modificada\n";
-----------------------------
c:\Temp>perl hello.pl
Nueva Array: Viernes Jueves Miercoles Martes Lunes

Sort (ordena alfabéticamente la matriz)

1
2
3
4
5
6


@semana_laboral = ("Lunes","Martes","Miercoles","Jueves","Viernes");
@semana_modificada = sort (@semana_laboral);
print "Nueva Array: @semana_modificada\n";
-----------------------------
c:\Temp>perl hello.pl
Nueva Array: Jueves Lunes Martes Miercoles Viernes

Pop (elimina el último elemento de la matriz)

1
2
3
4
5
6
7
8
9


@semana_laboral = ("Lunes","Martes","Miercoles","Jueves","Viernes");
$semana_modificada = pop (@semana_laboral);
print "Nueva Array: $semana_modificada\n";
print "Array original: @semana_laboral\n";

-------------------
c:\Temp>perl hello.pl
Nueva Array: Viernes
Array original: Lunes Martes Miercoles Jueves

Push (añade elementos al final de la matriz)

1
2
3
4
5
6


@semana_laboral = ("Lunes","Martes","Miercoles","Jueves","Viernes");
push (@semana_laboral, "NUEVO");
print "Array original: @semana_laboral\n";
----------------
c:\Temp>perl hello.pl
Array original: Lunes Martes Miercoles Jueves Viernes NUEVO

Shift (elimina el primer elemento de la matriz)

1
2
3
4
5
6
7
8


@semana_laboral = ("Lunes","Martes","Miercoles","Jueves","Viernes");
$semana_modificada = shift (@semana_laboral);
print "Nueva Array: $semana_modificada\n";
print "Array original: @semana_laboral\n";
----------------------------
c:\Temp>perl hello.pl
Nueva Array: Lunes
Array original: Martes Miercoles Jueves Viernes

Unshift (añade elementos al principio de la matriz)

1
2
3
4
5
6


@semana_laboral = ("Lunes","Martes","Miercoles","Jueves","Viernes");
unshift (@semana_laboral, "NUEVO");
print "Array original: @semana_laboral\n";
---------------------
c:\Temp>perl hello.pl
Array original: NUEVO Lunes Martes Miercoles Jueves Viernes

Split

Se utiliza split para dividir una cadena larga (escalar), en secciones más pequeñas, conformando una matriz.

1

@matriz = split("patrón",$cadena);

Vamos a verlo con un ejemplo práctico:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


$semana_laboral = ("Lunes\nMartes\nMiercoles\nJueves\nViernes");
print $semana_laboral;

@semana = split("\n",$semana_laboral); #Creamos una matriz con los valores del escalar
print @semana;
----------------------
c:\Temp>perl hello.pl
Lunes
Martes
Miercoles
Jueves

ViernesLunesMartesMiercolesJuevesViernes
c:\Temp>

Join

Join es la inversa a Split, en este caso se utlizar para concatenar los diferentes elementos de una matriz, dentro de una única cadena, utilizando un patrón para diferenciarlos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$escalar = join("patrón",@matriz);
@semana_laboral = ("Lunes","Martes","Miercoles","Jueves","Viernes");
print "@semana_laboral\n";

$semana = join("--",@semana_laboral); #Creamos un escalar con los valores de la matriz
print $semana;
-------------------------------
c:\Temp>perl hello.pl
Lunes Martes Miercoles Jueves Viernes

Lunes--Martes--Miercoles--Jueves--Viernes

Matrices Asociativas

Se trata de un tipo especial de Matriz. También se le conoce como Array Asociativo, o Hash. En ellos, los elementos dentro de la propia matriz son referenciados mediante otros valores, en lugar de por su posición, como se hace en las matrices normales.

Se identifican por el símbolo %, poniendolo delante del nombre como es habitual.

Pero vamos a verlo con ejemplos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


 #asignamos valores a una tabla hash
 my %colorfruta;

 $colorfruta{"verde"}="kiwi";
 $colorfruta{"amarillo"}="platano";
 $colorfruta{"rojo"}="sandía";
 $colorfruta{"naranja"}="naranja";

 print "Una fruta verde es: ".$colorfruta{"verde"}."\n";
---------------------------
c:\Temp>perl hello.pl
Una fruta verde es: kiwi

También se pueden definir así:

1
2
3
4
5


%dias=("lunes" => L,"martes" => M,"miercoles" => X,"jueves" => J,"viernes" => V,"sabado" => S,"domingo" => D);
 print "La representacion del Martes es :". $dias{"martes"}." \n";
------------------------
c:\Temp>perl hello.pl
La representacion del Martes es :M

Podemos extraer fácilmente tanto las claves como los valores, con «keys» y «values«:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


 my %colorfruta;

 $colorfruta{"verde"}="kiwi";
 $colorfruta{"amarillo"}="platano";
 $colorfruta{"rojo"}="sandía";
 $colorfruta{"naranja"}="naranja";


#vemos las CLAVES Keys 
@keys = keys(%colorfruta);
print "Claves: @keys\n";

#Vemos los VALORES Values
@values = values(%colorfruta);
print "Valores: @values\n";
----------------------
c:\Temp>perl hello.pl
Claves: verde amarillo naranja rojo

Valores: kiwi platano naranja sandia

Manejo de Ficheros

Input

La entrada estándar (por teclado) corresponde a «». Esto se suele abreviar utilizando simplemente «<>«

Se suele utilizar chomp para eliminar cualquier intro o carácter extraño al final de la cadena introducida.

Como siempre, vamos a verlo más claro con un ejemplo:

1
2
3
4
5
6
7
8
9


print "Hola. Dime cuantos años tienes";
$edad = <STDIN>; 
chomp($edad);
print "Has dicho que tienes $edad años!";
-----------------------
c:\Temp>perl hello.pl
Hola. Dime cuantos años tienes
20
Has dicho que tienes 20 años!

Abrir, leer, modificar y cerrar ficheros

Para operar con un fichero, primero es necesario abrirlo asociándolo con un FILEHANDLE. Vamos a explicarlo gráficamente:

1
2
3
4
5


open (FILE, "fichero.txt");
@array = <FILE>;
close(FILE);
print @array
open (FILE, "fichero.txt");

Esto abre el fichero. en este caso el fichero está en el mismo path que nuestro script, pero se podría indicar la ruta absoluta: «c:\tmp\fichero.txt«

Es una buena práctica utilizar la función «or die«. De esta forma si el fichero no existe, se genera un error. Por ejemplo:

1
2


 open (FILE, "fichero.txt") or die "ERROR: No se encuentra el fichero.";
@array = ;

Con esto volcamos el contenido del fichero en un array que se llama «array».

1

close(FILE);

Como ya hemos terminado con el fichero, lo cerramos. Perl lo haría automáticamente, pero es una buena práctica para evitar sorpresas inesperadas.

1

print @array

imprimos el array

Al igual que con la redirección estándar, podemos utilizar «>» o «»» para añadir contenido a un fichero.

«>» Se crear un nuevo fichero en el que escribir (si existe se vacía).

1
2
3
4
5
6
7


open (FILE, ">fichero.txt");
$string = <FILE>;
print FILE "Hello, world!";
close(FILE);
-----------------------
c:\Temp>type fichero.txt
Hello, world!

«»» Se añade el contenido al final del fichero.

1
2
3
4
5
6
7
8


open (FILE, ">>fichero.txt");
$string = <FILE>;
print FILE "ADIOS!!!!";
close(FILE);
--------------------------
c:\Temp>type fichero.txt
Hello, world!
ADIOS!!!!

Introducción a Perl - 1

Mon, 11 Mar 2019 00:00:00 +0000

Introducción a Perl

¿Qué es un lenguaje de programación?

Un lenguaje de programación es básicamente un lenguaje estructurado que tiene como fin el desarrollo de programas informáticos para controlar procesos físicos o lógicos de una computadora.

Esto de manera sencilla, es decirle a un ordenador lo que quieres que haga, pero en un lenguaje que él pueda comprender (el Lenguaje de Programación).

Ha muchos lenguajes de programación:

C
C++
Basic
Java
Python
Pascal
…

Interpretado o Compilado, Alto o Bajo Nivel

Cuando escribimos un programa, en el lenguaje de programación que sea, según lo que se haga con el mismo puede ser de dos tipos:

Lenguaje Interpretado

Un lenguaje interpretado necesita de otro programa, llamado intérprete, para poder procesar el código cada vez que el programa es ejecutado.

Lenguaje Compilado

Un lenguaje compilado utiliza un compilador para hacer todos los procesos requeridos una única vez antes de que el código se pueda ejecutar. Después de ser compilado, el programa se puede lanzar directamente. En general, los programas funcionan más rápido una vez compilados.

Respecto a la «facilidad» a la hora de elaborar el programa, podemos encontrar dos tipos de lenguajes:

Bajo Nivel

Los lenguajes de Bajo Nivel dependen directamente del conjunto de funciones implementadas en el hardware, y utilizando una semántica muy poco legible

Alto Nivel

Los lenguajes de Alto Nivel tienen su semántica y sintaxis más orientado a facilitar el entendimiento por parte del programador. Se procura que su estructura sea lo más parecida a un lenguaje natural.

Perl?

En el caso que nos ocupa (Perl), se trata de un lenguaje de programación de alto nivel, interpretado, y dinámico.

Fue desarrollado por Larry Wall en 1987, y desde aquella fecha continúa bajo un activo desarrollo.

Las ventajas de Perl son que es muy fácil de aprender, y se pueden hacer muchas cosas sabiendo cuatro cosillas. Además es rápido de escribir, es multiplataforma, y es código libre.

Mas información en Wikipedia

Instalación de Perl

En Linux se encuentra preinstalado en la mayoría de distribuciones, por lo que nos vamos a centrar en su instalación bajo Windows.

Debemos bajarnos el paquete correspondiente a nuestra arquitectura desde Strawberryperl.com o ActiveState

Una vez descargado (unos 100MB), procedemos a la instalación, como cualquier otro programa de Windows.

Tardará unos minutos en completar la instalación, y después de eso podemos abrir la consola de comandos (cmd) y ejecutar lo siguiente para ver la versión actual.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


C:\Users\user>perl -v

This is perl 5, version 28, subversion 1 (v5.28.1) built for MSWin32-x64-multi-thread

Copyright 1987-2018, Larry Wall

Perl may be copied only under the terms of either the Artistic License or the
GNU General Public License, which may be found in the Perl 5 source kit.

Complete documentation for Perl, including FAQ lists, should be found on
this system using "man perl" or "perldoc perl". If you have access to the
Internet, point your browser at http://www.perl.org/, the Perl Home Page.


C:\Users\user>

En este caso nos está diciendo que tenemos la versión v5.28.1

Hello World

Ya tenemos todo preparado para ponernos manos a la obra con nuestro primer programa. No podría ser otro que el típico «Hello World».

Para editar el código Perl, se emplea un simple editor de texto. Personalmente te recomiendo Notepad++ o Sublime Text

Creamos un fichero llamado hello.pl, con el siguiente contenido:

1
2


#!/usr/bin/perl
print "Hello World!"; #esto es un comentario

La primera línea indica el programa utilizado para lanzar el script
la instrucción print imprime lo que le indiquemos a continuación
Cada instrucción va terminada por un «;» (importante)
Cualquier texto detrás de «#» se considera como un comentario y es omitido.

Ahora podemos lanzar el script desde la consola de comandos (cmd), indicando «perl» seguido del nombre del script:

1
2
3


c:\Temp>perl hello.pl
Hello World!
c:\Temp>

Listo!! con esto hemos lanzado nuestro primer programa en Perl.

Nos vemos en la segunda parte

Introducción a Perl - 2

Mon, 11 Mar 2019 00:00:00 +0000

Introducción a Perl - 2

Continuamos con la segunda entrega de la Introducción a Perl. En esta ocasión vamos a adentrarnos en poco en el mundo de las variables

Nomenclatura

Cualquier programa de Perl, cuenta con Variables, funciones, clases, packages, etc. Cualquier nombre debe cumplir las siguientes características:

Empezar por una letra o un guión bajo «_»
Puede incluir cualquier combinación de letras, números o guiones bajos.
Los nombres son «Case Sensitive». Se diferencia entre mayúsculas y minúsculas
Pueden tener cualquier longitud.

A la hora de escojer un nombre, debemos utilizar una nomenclatura que nos resulte informativa, y se pueda entender de manera últil y clara.

Ejemplos válidos:

1
2
3
4
5


$correcto;

%_otro_correcto;

@correcto1;

Ejemplos inválidos:

1
2
3
4
5


$una incorrecta;

@45;

%+incorrecto+;

Nomenclatura de las variables

Una variable es un espacio de memoria (o un lugar) donde almacenamos un valor. Este «lugar» o variable, podemos manipularlo, o referirnos a él directamente.

Los nombres de las variables siempre tienen al principio un símbolo, indicante el tipo al que pertenece esa variable.

Hay tres tipos de variables:

Escalares: $ El escalar representa el tipo básico en Perl. Permite representar enteros, reales y cadenas de caracteres
Matrices o arrays: @ Es una lista de datos de tipo escalar. Cada elemento de la lista es una variable escalar a la que se le asocia un valor
Matrices o listas asociativas: % Una matrix asociativa está indexada por cadenas en lugar de por números. Un elemento está indexado por el anterior formando ambos parejas del tipo (clave, valor).

Sin embargo, vamos a ir viendo poco a poco estos tipos de variables.

Variables Escalares

Este tipo de variables almacenan un único valor.

Su nombre comienza por $

El valor almacenado en las variables escalares puede ser modificado durante la ejecución del programa

Se pueden almacenar datos de cualquier tipo: cadena de texto, números enteros, reales…

1
2
3


$nombre = "Martin";
$edad = 24;
$precio = "22.15";

Ahora que ya tenemos una pequeña idea, vamos a empezar a utilizar este tipo de variables.

Para asignar un valor a una variable, se utiliza =

1
2
3


$nombre = "Martin";

$nombre = "Martin\n";

A la hora de manejar strings, como en el caso de arriba, se pueden utilizar varios comodines. Mas información al respecto. Sin embargo estos son los más útiles:

\n – Nueva linea
\t – tabulador

El punto (.) sirve para concatenar dos strings:

1
2
3
4
5
6


$nombre = "raul";
$apellido = "diez";
print $nombre.$apellido;
--------------------
PS C:\Temp> perl .\hello.pl
rauldiez

También podemos utilizar operadores aritméticos para operar con este tipo de variables:

Sumar +
Restar –
Multiplicar *****
Dividir /
Exponente **

1
2
3
4
5
6


 $x = 2;
 $y = 5;

 $suma = $x + $y;
 $resta = $y - $x;
 $dividir = $x / $y;

Podemos redondear también a los decimales que queramos, con «printf«:

1

 printf "Rendondeando: 0.2f", $dividir;

length nos devuelve la longitud en caracteres:

1
2
3
4
5
6
7
8
9


$x = 22;
$y = 534;

$longitudy = length $y;

print "la longitud de $y es $longitudy";
----------------
PS C:\Temp> perl .\hello.pl
la longitud de 534 es 3

Si utilizamos comillas simples, en vez de las dobles, se imprime de forma literal:

1
2
3
4
5
6
7
8
9


$x = 22;
$y = 534;

$longitudy = length $y;

print 'la longitud de $y es $longitudy';
--------------------
PS C:\Temp> perl .\hello.pl
la longitud de $y es $longitudy

uc (uppercase) – devuelve el valor en mayúsculas

lc (lowercase) devuelve el valor en minúsculas

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


$x = "Martin";
$y = "Es RuBiO";

print "$x $y\n";

$mayusc = uc $x; #pasamos a mayusculas
$minusc = lc $y; # pasamos a minusculas

print "$mayusc $minusc\n";
-------------------
PS C:\Temp> perl .\hello.pl
Martin Es RuBiO
MARTIN es rubio