Los Paquetes en Python.

Crear, Empaquetar y Distribuir los paquetes en Python.

Podemos decir que un paquete en Python es una carpeta que contiene varios módulos que podemos utilizar en nuestros programas. Para que Python sepa que se trata de un paquete y no de una carpeta normal, basta en principio, con poner dentro un archivo llamado __init__.py sin contenido. 

La estructura tipo de un paquete es:

paquete/
    |-- __init__.py
     |-- modulo_1.py
     |-- modulo_2.py

Los paquetes se parecen a las antiguas cadenas de música que se formaban añadiéndole módulos. (cassettes, amplificador, plato, cd etc). Vamos a imaginar que tenemos un programa (paquete) de sonido y que ese paquete a su vez tiene dos módulos. Uno que sirve para reproducir diferentes formatos de música y otro que aplica diversos efectos a  los sonidos. 

La forma de acceder a el contenido de esos paquetes es siguiendo la estructura:

<paquete>.<subdirectorio>.<módulo>

En el ejemplo que planteábamos puede tener la siguiente estructura:

sound/
    |-- __init__.py
     |-- formatos/
            __init__.py
            wadread.py
            mp3read.py
     |-- efectos/
            __init__.py
            soundround.py
            reverse.py
            autotune

De esta forma si queremos utilizar alguno de los módulos que lo componen haríamos:

# carga el modulo reverse para utilizar todo lo que lo compone
import sound.efectos.reverse

O bien también podemos usar:

# carga el modulo reverse para utilizar todo lo que lo compone
from sound.efectos import reverse

Python incluye muchos módulos y paquetes en su instalación que es lo que se conoce como librería estándar. También aún más grande, son los paquetes que podemos instalar y que han sido desarrollados por la comunidad para hacer miles de cosas.

Aunque el archivo __init__.py basta con que este vacío para que Python entienda que esa carpeta se trata de un paquete, se pueden poner instrucciones dentro de ese archivo. Por ejemplo si en __init__.py el que está debajo de la carpeta efectos/ ponemos la variable __all__ así:

__all__= ['sounround', 'reverse'] 

Si realizamos la importación de todos los módulos usando el *, pej. from sound.efectos import * solo nos cargará los módulos especificados en la variable y no el modulo autotune que también forma parte del mismo.

Empaquetar paquetes para que estén disponibles en cualquier parte.

Si queremos que un paquete que hemos creado este disponible para poder utilizarlo en otro equipo, o para que se pueda instalar directamente en el equipo al igual que los paquetes que forman parte de la biblioteca estándar, lo primero que tenemos que hacer es empaquetarlo. 

Para ello, aunque existen varios módulos que se pueden utilizar, vamos a centrarnos en uno llamado Setuptools. Este nos va a facilitar todo lo que vamos a necesitar para distribuir nuestros propios módulos e incluso publicar nuestros paquetes en el repositorio público PyPi (Python Package Index) directamente desde el terminal. 

Para distribuir nuestro código es imprescindible que lo tengamos en forma de paquete. Su estructura básica sería:

| setup.py # Fichero que contiene toda la información de la instalación + mates/ # Directorio del paquete al mismo nivel que setup.py | __init__.py # Fichero que indica que el directorio es un paquete | modulo.py # Módulo o script que contiene el código principal.

 Lo que estamos diciendo es que vamos a empaquetar el paquete al que hemos llamado "mates" cuyo código esta recogido en fichero-modulo.py

Empecemos viendo un poco el fichero setup.py. Este archivo contiene toda la información que el programa necesita para realizar la instalación del paquete. Una parte del mismo son metadatos que identifican el quien y que del programa, mientras que la otra es la que se utiliza para preparar el proceso de instalación propiamente dicho.

De forma estándar se suelen usar una serie de campos ya definidos para estructurar el paquete. Creamos el archivo setup.py con la siguiente estructura:

from setuptools import setup

setup(
    name = "Mates",  # Nombre
    version = "0.1",  # Versión de desarrollo
    description = "Paquete de matemáticas",  # Descripción del funcionamiento
    author = "Nombre_del_autor",  # Nombre del autor
    author_email = 'correo@delautor',  # Email del autor
    license = "GPL",  # Licencia: MIT, GPL, GPL 2.0...
    url = "http://ejemplo.com",  # Página oficial (si la hay)
    packages = ['prueba'],
)

De aquí lo más importante es el apartado packages, donde se va a recoger todos los paquetes que vamos a empaquetar. En el ejemplo previo solo tenemos un paquete, mates. Pero eso no implica que no pudiésemos tener cientos de ellos en cuyo caso o bien los vamos añadiendo uno a uno (con el trabajo que ello implica o bien) o bien utilizamos (después de importarla) la siguiente función que hará el trabajo por nosotros:

from setuptools import setup, find_packages

setup(# aqui irían todos los metadatos,
      packages = find_packages(),
    )

Otra cosa importante son las dependencias de las que dependa el buen funcionamiento de nuestro paquete. Por ejemplo si nuestro paquete necesitará el paquete externo matplotlib (para mostrar algún tipo de gráfico) para funcionar, a la hora de empaquetarlo hay que tener en cuenta todos los paquetes de los que depende el nuestro y que va a necesitar para su buen funcionamiento.

En su momento lo instalamos desde el terminal antes de importarlo con:

pip3 install matplotlib

Pero como lo que queremos al distribuir nuestro paquete es que este se instale de forma automática, lo haremos con la siguiente instrucción:

setup(...,
      install_requires=["matplotlib"],
)

Como no hemos indicado ninguna versión, se nos instalará la más actual que haya en ese momento. Pero por compatibilidad quizá queramos que se instale la librería exacta que hayamos utilizado. Esto se puede hacer fácilmente, solo hay que variar un poco el comando:

setup(...,
      install_requires=["matplotlib==3.5.0"],
)

Hay que decir que cuando tienes un programa completamente elaborado normalmente has usado muchas librerías que a su vez requieren de otras. Para saber exactamente las librerías que has usado en tu proyecto, puedes listarlas desde el terminal usando alguna de estas dos expresiones:

pip3 list

pip3 freeze

Se suele utilizar más la segunda porque podemos pasar esa lista de todas las librerías que hemos utilizado a un archivo:

pip3 freeze > requirement

y luego incorporarlas a setup.py para indicar las dependencias de la siguiente forma:

setup(...,
      install_requires=[i.strip() for i in open("requirements.txt").readlines()],
)

Probando el paquete en modo de desarrollo.

Una vez que tenemos el paquete preparado, si queremos probar que funciona correctamente en modo de desarrollo, lo mejor es ejecutarlo en un entorno local, en nuestro usuario. Para ello empezaremos creando una carpeta y dentro crearemos un entorno virtual

> python3 -m venv miEntorno

Luego pondremos dentro, la carpeta que contiene el paquete y el archivo setup.py. Quedaría algo como esto:

Desde el terminal activamos el entorno virtual:

 > source miEntorno/bin/activate

y una vez ahí, tecleamos el siguiente comando:

(miEntorno)$ python -m pip install -e .

Se intentará desinstalar la versión anterior si existe y se instalará la nueva versión de nuestro paquete, que es de momento la única que tenemos.

Si hacemos dentro del entorno virtual un pip list, veremos algo así:

Si finalmente quisiéramos instalarlo definitivamente en nuestro equipo entonces utilizaríamos, ya fuera del entorno virtual:

 > python3 setup.py install

Pero tenemos que tener en cuenta que una vez hecho esto, el paquete se instala internamente en el ordenador y ya no podremos modificarlo sin antes desinstalarlo, lo cual tenemos que hacer con el comando pip3, buscando el nombre del paquete con pip3 list y desinstalarlo con:

 > pip3 uninstall <nombre del paquete>

¿Y que pasa si queremos pasar el paquete a un amigo es decir DISTRIBUIRLO?

Una vez que ya lo tenemos todo listo preparar un paquete para compartir con un amigo, por ejemplo, es muy sencillo.  Solamente tenemos que ejecutar desde el terminal es siguiente comando:

python3 setup.py sdist

Este comando nos creará un fichero comprimido que podremos compartir con quien queramos. Se va a generar un directorio llamado dist/ en la carpeta del paquete y si miramos dentro, estará el fichero que necesitamos.

Este fichero ya podremos compartirlo con quien queramos y para instalarlo lo trataremos igual que cualquier otro paquete:

pip install nombre_del_fichero_comprimido 

Lo podemos también desinstalar de la misma forma pero usando el nombre del paquete:

pip uninstall nombre_paquete

Y aquí finalizamos este capitulo. Dejamos para uno próximo como subir paquetes al repositorio de PyPi aunque si quieres ver material sobre el tema en español puedes encontrarlo aquí.

Módulos en Python.

Generalidades de los módulos.

Los módulos son programas con extensión normalmente .py o .pyc que contiene un conjunto de funciones, variables o clases que se pueden ejecutar en otros programas. Esto es muy útil ya que nos permite reutilizar código y organizarlo todo mejor. 

Vamos a verlo con un ejemplo. Vamos a crear un archivo de Python llamado mates.py que tenga unas funciones que sumen o resten dos números y lo ejecutaremos para ver si funciona.

mates.py

""" Suma o resta dos números dados"""


def sumar(x, y):
    """Suma dos números dados."""
    return x + y


def restar(x, y):
    """Resta dos números dados."""
    return x - y


print(sumar(2, 3))
print(restar(12, 2))

Salida:

5
10

Ahora que vemos que funciona, estaría bien si cada vez que creásemos un programa que tuviera que sumar o restar números no tuviésemos que volver a escribir todo este código. Como ya tenemos las funciones escritas, vamos a ver como podemos utilizarlas. Entramos en el shell de Python y escribimos:

# Para importar el módulo ponemos el nombre del archivo pero sin la extensión.
import mates

Salida:

5
10

¡Pero que es esto! ¡ Como ves al importar un módulo se ejecuta todo el código que está escrito en el programa! Para poder ejecutar un programa bien como un programa principal o como un módulo en otro programa se suele utilizar "if __name__ == "__main__": Este código lo verás con frecuencia. Volvemos a rescribir mates.py para entender su funcionamiento.

""" Suma o resta dos números dados"""


def sumar(x, y):
    """Suma dos números dados."""
    return x + y


def restar(x, y):
    """Resta dos números dados."""
    return x - y

if __name__ == "__main__":
    print(sumar(2, 3))
    print(restar(12, 2))

Cuando el interprete de Python ejecuta mates.py, si es el programa principal, la variable __name__ se establecerá como __main__ y se ejecutará el código que va a continuación del condicional.

Ahora bien, si el código se está importando desde otro programa, como un módulo, la variable __name__ se establecerá con el nombre del módulo (mates en nuestro caso) y no se ejecutarán las líneas de código que van a continuación.

Visto lo anterior, existen tres formas de importar un módulo.

1) Usando import podemos importar todo el contenido (Ponemos el nombre del archivo pero sin la extensión). Si ahora volvemos al shell de Python e importamos todo el módulo:

>>> import mates
>>> 

Veremos que ya no se muestran los resultados de sumar 2 y 3 o de restar 12 menos 2. Sin embargo si que tenemos a nuestra disposición ambas funciones del módulo. Podemos acceder a ellas con el nombre del módulo seguido del componente o función. Probemos:

Python 3.8.10 (default, Nov 26 2021, 20:14:08) 
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import mates
>>> mates.sumar(8,10)
18
>>> mates.restar(15,4)
11
>>> 

2) También podemos importar únicamente los componentes que nos interesen. Por ejemplo si solo nos interesa importar la función sumar() del módulo mates, podemos importarla directamente sin tener luego que especificar el módulo del que depende al utilizarla:

Python 3.8.10 (default, Nov 26 2021, 20:14:08) 
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from mates import sumar
>>> sumar(6,7)
13
>>> 

Puedes ver que de esta forma no es necesario usar el nombre del módulo para llamar a la función. No es necesario poner mates.sumar(6,7) con sumar(6,7) ya nos funciona. De hecho si lo intentas invocar así te dará un error.

3) Aunque no se suele hacer o recomendar puedes importar todos los componentes del módulo con un *. Por ejemplo para importar todo lo del módulo (sumar y  restar en este caso):

Python 3.8.10 (default, Nov 26 2021, 20:14:08) 
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from mates import *
>>> sumar(4,5)
9
>>> restar(14,7)
7
>>> 

Rutas de los módulos.

Python por defecto busca el módulo en el mismo directorio o carpeta que el programa o script que lo llama y si no lo encuentra ahí, lo buscará en el directorio de instalación de Python. Puedes ver si quieres las carpetas donde se buscarán los módulos con los siguientes comandos desde el shell de Python:

>>> import sys
>>> print(sys.path)

Sin embargo también es posible acceder a módulos que estén en una subcarpeta dentro de donde este el script que lo importa. Vamos a imaginar la siguiente estructura. 

. ├── main.py ├── carpeta │ └── modulo.py

Desde el programa main.py se importará el modulo que está en una subcarpeta a un nivel inferior.

Podemos hacerlo de la siguiente forma:

main.py

import carpeta.modulo o from carpeta.modulo import *

¿Y que pasa si queremos crear una carpeta en otra parte donde se encuentren los módulos creados por nosotros? Pues entonces para poder importarlos tenemos que añadir la ruta de la misma al sys.path para que Python pueda buscarla. 

>>> import sys
>>> sys.path.append('/ruta/de/los/modulos')

No obstante si esto lo ejecutas desde el shell de Python solo te valdrá para esa sesión ya que al salir de la misma no se conserva la modificación.

Cambiando los nombres de los modulos con 'as'

En ocasiones cuando utilizas módulos, te encuentras con que los nombres de los mismos son muy largos o difíciles de recordar. En esas ocasiones es posible utilizar un "alias" para los mismos usando 'as' lo que facilita las cosas.

Imagina que tenemos que importar un módulo que se llama thinker_drawing que tiene lo siguiente:

thinker_drawing.py

render = "renderizando ventana"

y que lo queremos importar en el programa en el que estamos trabajando, que es principal.py. En vez de usar el nombre original para trabajar con el módulo:

principal.py

import thinker_drawing 
print(thinker_drawing.render)

podemos trabajar de forma más cómoda usando 'as':

principal.py

import thinker_drawing as td
print(td.render)

Funciones útiles después de importar un módulo.

Son dir() y help().

El primero de ellos dir() nos sirve para ver cuales son los elementos que componen un módulo. Si lo utilizamos sin argumentos nos permite ver los nombre (variables, funciones, clases etc) existentes en nuestro espacio de nombres de Python y si le pasamos como argumento un modulo después de importarlo nos dará su contenido o cosas que podemos usar de ese modulo.

print(dir())

['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']

El segundo help() nos mostrará información de ayuda del módulo.

Por ejemplo en nuestro módulo de matemáticas (mates.py):

""" Suma o resta dos números dados"""


def sumar(x, y):
    """Suma dos números dados."""
    return x + y


def restar(x, y):
    """Resta dos números dados."""
    return x - y

if __name__ == "__main__":
    print(sumar(2, 3))
    print(restar(12, 2))

si lo importamos desde otro script o desde el shell de Python y ejecutamos help() veremos la ayuda del módulo:

principal.py

import mates
print(help(mates))

Salida:

Help on module mates:

NAME
    mates - Suma o resta dos números dados

FUNCTIONS
    restar(x, y)
        Resta dos números dados.
    
    sumar(x, y)
        Suma dos números dados.

Recargando módulos.

Es importante señalar que por muchas veces que importemos un módulo este solamente se ejecutará una vez. Por ejemplo si tenemos un modulo que imprime un mensaje por pantalla, a pesar de que lo importemos muchas veces solo se cargará o ejecutará una vez.

imprimir.py

# mimodulo.py

print("Importando mimodulo")

varios_import.py

import imprimir
import imprimir
import imprimir

Salida:

Importando mimodulo


** Process exited - Return Code: 0 **

Press Enter to exit terminal

Si queremos que un modulo se recargue varias veces, tenemos que usar la biblioteca importlib y declararlo de la siguiente manera:

varios_import.py

import imprimir
import importlib
importlib.reload(imprimir)
importlib.reload(imprimir)

Salida:

Importando mimodulo
Importando mimodulo
Importando mimodulo


** Process exited - Return Code: 0 **
Press Enter to exit terminal

Estructura formal de un modulo.

Para finalizar si en alguna ocasión queremos crear un módulo que sea más o menos formal, deberíamos usar esta estructura parecida a la siguiente para facilitar la máxima información posible sobre quien programa el módulo, que hace, con que licencias se distribuye etc 

#!/usr/bin/env python3
#-*- coding: utf-8 -*-
__author__ = " "
__copyright__ = " "
__credits__ = " "
__licence__ = " "
# tipo de licencia bajo la que se distribuye, por ej. GPL
__versión__ = " "
# número de versión del modulo
__email__=" "
__status__=" "
# Si está en desarrollo (Development) o finalizado (Production)


# Código del módulo

¿Como usar OpenMediaVault y PLEX en una Rapsberry pi?

Instalación y configuración de OMV.

Instalar Openmediavault en una Rapsberry Pi 4 es relativamente sencillo. Aunque existen varias formas vamos a ver la siguiente. Lo primero que necesitaremos es una instalación limpia de Raspberry Pi OS. Es IMPORTANTE usar la versión lite, sin versión de escritorio ya que si no está guía no funcionará.

Para ello vamos a utilizar el programa Raspberry Pi Imager para grabar una imagen limpia en una tarjeta, en mi caso de 8gb. 

Abrimos el programa y donde pone "Operating System" escogemos Rapsberry Pi OS (others) y seleccionamos Rapsberry Pi Os lite (32 bits)

Si utilizamos la combinación de teclas Ctrl + Shift + x accederemos a una pantalla donde podemos establecer la contraseña del usuario pi y activar el protocolo ssh lo cual es muy útil para manejar la rapsberry desde otro ordenador.

Después es cuestión de seleccionar la tarjeta sd donde vamos a grabar la imagen y darle a "write".

Al arrancar la Pi 4 con la nueva imagen y antes de instalar el Openmediavault actualizamos el sistema operativo con:

sudo apt update

sudo apt upgrade

Como la distribución viene en inglés, y más que nada para que no salga un error repetitivo en la instalación, que aunque no afecta al programa es muy molesto. Vamos a configurar previamente la variable local en Español.

Editamos la variable local por defecto:

sudo nano /etc/default/locale

y cambiamos la línea por defecto a:

LANGUAGE=es_ES.UTF-8
LANG=es_ES.UTF-8
LC_ALL=es_ES.UTF-8

y luego tecleamos las siguientes instrucciones:

sudo locale-gen es_ES.UTF-8
sudo dpkg-reconfigure locales

Aquí nos saldrá una pantalla donde tenemos que deseleccionar en_EN.UTF-8 y seleccionar es_ES.UTF-8 y darle a OK. 

Ahora vamos a lo importante. Para instalar Openmediavault tecleamos la siguiente instrucción:

sudo wget -O - https://github.com/OpenMediaVault-Plugin-Developers/installScript/raw/master/install | sudo bash

y tranquilamente nos podemos ir a merendar porque va a tardar un rato. (unos 20 minutos)

Puedes encontrar una guía completa de todo el proceso en esta dirección.

Después de la pausa, tenemos que abrir un navegador e ir a la dirección que tenga nuestra Rapsberrry en nuestra red doméstica. Veremos lo siguiente:

El nombre del usuario por defecto es admin y la contraseña por defecto es openmediavault

Lógicamente, lo primero que debemos hacer es cambiar la contraseña por defecto del administrador. Para ello en la parte derecha de la pantalla encontramos las opciones de configuración:

y pulsando en ella podremos cambiar la contraseña por defecto.

Deberíamos también comprobar si existe alguna actualización. Lo podemos encontrar a la izquierda entrando en el panel de SISTEMA y luego en Gestión de Actualizaciones. 

Como por defecto el usuario pi no es muy recomendable utilizarlo por temas de seguridad, deberíamos añadir un usuario distinto de pi. Como mínimo este usuario debería tener, al menos, los siguientes permisos de grupo adm, root, ssh, sudo, users 

Para hacer esto, vamos al menú de la izquierda y si pinchamos en usuarios podemos encontrar la opción para crear nuevos usuarios.

En mi caso quedaría de la siguiente forma:

Cuando lo tengamos todo configurado le damos a salvar para guardar los datos.

Una vez hecho lo anterior es hora de conectar el disco duro que vayamos a usar. Para ello, apagamos OMV y la Rapsberry haciendo clic en la parte superior derecha y seleccionando Apagar. Cuando ya este completamente apagada, conectamos el disco duro que queramos añadir a la Rapsberry. Yo he usado un disco antiguo que tenia por casa y que está formateado en NTFS

Volvemos a encenderla y esperamos que este en línea. Volvemos a entrar con el usuario Admin y es hora de Conectar virtualmente la unidad de discos y montarla en el sistema.

Empezamos yendo a la parte izquierda, seleccionando Almacenamiento y dentro de este apartado Sistema de Archivos. 

Aun no aparece nada, porque aunque tenemos conectado virtualmente el disco hay que montarlo para que lo reconozca el programa. Simplemente le damos al más y luego a Montar. 

En la siguiente pantalla tan solo debemos pulsar en Sistema de Archivos y seleccionar nuestro disco duro (que tiene lógicamente que coincidir con el que tengamos conectado) y pulsamos en Salvar.

El siguiente paso es crear una carpeta compartida que nos servirá para almacenar nuestros datos desde otros equipos de la red. Cada vez que hagamos un cambio en el programa este nos dirá que existen cambios de configuración pendientes y que debemos aplicarlos para que surjan efecto. Le decimos que si y aplicamos los cambios.

Una vez hecho lo anterior vamos al menú de la izquierda y seleccionamos Carpetas Compartidas y luego Crear.  Es ahí donde tenemos que poner el nombre de nuestra carpeta compartida (yo la llamaré Apestosa) y como no quiero variar los permisos que tiene le doy a salvar.

A continuación voy a entrar en los privilegios de esa carpeta y dar opciones de lectura/escritura al usuario que cree antes. (chema-admin). Desde aquí podríamos modificar a nuestra necesidad los privilegios de acceso a esa carpeta. (Esta arriba a la derecha del símbolo más y al lado de editar.)

Luego aplicamos los cambios y ya lo tenemos.

Recapitulando. Hemos conectado y montado el disco y creado una carpeta compartida, pero aún tenemos que elegir con que protocolo nos vamos a conectar.

Aunque voy a utilizar samba porque el equipo que me interesa conectar tiene windows, también puede que te interese usar nfs si usas linux o mac. En ambos casos es muy parecido.

Primeramente vamos a la parte izquierda, en el menú lateral y seleccionamos NFS.  Luego pinchamos en Compartidos y le damos a Crear.

Aquí en Shared Folder ya nos aparecerá la carpeta compartida que especificamos antes, así que solo tenemos que escogerla. En Cliente que es un campo obligatorio, tenemos que poner:

 192.168.1.0/24

En Privilegio ponemos Lectura/Escritura y finalizamos dándole a Salvar.

Ahora dentro todavía de NFS, en la parte izquierda seleccionamos Opciones, marcamos habilitado y le damos a Salvar.

Aplicamos los cambios y si todo ha ido bien (crucemos los dedos) ya lo tenemos. 

Ahora vamos a hacer lo mismo para configurar el protocolo Samba. Vamos a la parte izquierda, seleccionamos SMB/CIFS y luego pinchamos en Compartidos y Crear. Aquí solo tenemos que escoger nuestro directorio compartido y nada más. (ver que también está seleccionado la pestaña de habilitado)

Y al igual que antes, ahora en el menú de la izquierda de damos a Opciones y habilitamos el servicio. Finalizamos dándole a Salvar.

Ha llegado el momento de ver si lo que hemos hecho realmente funciona. Como medida preventiva voy a reiniciar la Raspberry Pi. Cuando termine, me voy a mi ordenador que tiene Windows, y dentro del explorador de archivos, busco donde pone red y ahí me aparece mi Rapsberry, que en mi red se llama GoalKeeper. 

Ahí tenemos que poner el nombre del usuario que creamos como alternativa al usuario pi en OpenMediaVault y que en mi caso era chema-admin. Tenemos que introducir también la contraseña y si todo ha ido bien, voila, nos aparecerá nuestra flamante unidad de red con el nombre que hayamos puesto a la carpeta compartida.

Para ver la velocidad de trasferencia le he pasado un video y se alcanzan velocidades de unos 16 mb/s en mi red usando un ordenador con Windows y conectado por wifi a la misma.

A parte de lo que hemos visto, OMV también te permite crear un servidor FTP, y tiene un montón de plugins y extras para por ejemplo instalar contenedores Docker.

Instalar Plex en nuestro NAS.

Para poder ver mis pelis y series directamente en una televisión smartTV desde cualquier parte o dentro de mi red voy a instalar Plex en la Rapsberry que esta corriendo OMV. 

Para empezar tenemos que entrar en la Rapsberry a través de SSH y una vez dentro actualizaremos el índice de paquetes e instalaremos las dependencias necesarias.  El proceso es un poco largo, que no complejo.

Empezamos por ver si tenemos todos estos paquetes y si no los instalaremos.

sudo apt install apt-transport-https curl wget

Para continuar deberíamos crear un archivo de repositorio que obtenga los archivos directamente del repositorio de Plex. Antes se usaba:

curl o wget https://downloads.plex.tv/plex-keys/PlexSign.key | sudo apt-key add –

pero este método está depreciado así que tendremos que hacer un poco de trabajo extra.

Lo primero que tenemos que hacer es descargar la antigua Plex Key:

wget https://downloads.plex.tv/plex-keys/PlexSign.key

Si usamos el comando "file" podremos ver si se corresponde con la clave pública de Plex. En la versión del Rapsbian que estamos utilizando este comando no esta disponible, así si quieres hacer esta comprobación que es opcional, tienes que instalarlo con "sudo apt install file".

Deberíamos ver algo como esto:

A continuación, ejecutamos la siguiente clave de importación en un llavero temporal.

gpg --no-default-keyring --keyring ./temp-keyring.gpg --import PlexSign.key

La salida debería ser algo como esto:

Ahora, exportaremos PlexGPGKey.gpg que usaremos para añadir el repositorio de Plex.

gpg --no-default-keyring --keyring ./temp-keyring.gpg --export --output PlexGPGKey.gpg

A continuación moveremos la clave gpg a un nuevo directorio, pero no la añadiremos a /etc/apt/trusted.gpg.d/

sudo mkdir -p /usr/local/share/keyrings

y movemos la llave que hemos generado a este directorio:

sudo mv PlexGPGKey.gpg /usr/local/share/keyrings/

Ahora que ya hemos solucionado lo de la clave gpg, importaremos el repositorio

echo deb [signed-by=/usr/local/share/keyrings/PlexGPGKey.gpg] https://downloads.plex.tv/repo/deb public main | sudo tee /etc/apt/sources.list.d/plexmediaserver.list

Antes de instalar Plex, es conveniente ejecutar el comando de actualización de paquetes.

sudo apt update

Y Finalmente instalamos Plex Media Server en la Rapsberry Pi usando:

sudo apt install plexmediaserver

Comenzará la instalación y ten en cuenta que durante la misma verás el siguiente mensaje.

Le damos Intro para aceptar la opción por defecto o tecleamos N como prefieras.

Para comprobar que Plex está correctamente instalado y funcionando tecleamos:

systemctl status plexmediaserver

Deberíamos ver algo parecido a esto:

Ahora que Plex está instalado y funcionando, tenemos que acabar la configuración utilizando un navegador. Para ello tenemos que abrirlo y navegar a la dirección IP de la rapsberry o el localhost si estamos trabajando directamente en ella.

En mi caso como acedo a través de otro ordenador utilizaré mi dirección de red para conectarme:

http://[dirección Ip de la Rapsberry]:32400/web o http://localhost:32400/web.

Veremos algo similar a esto:

Ahora ya podemos iniciar sesión, con diversos medios (google, facebook etc) o también puedes registrarte y entrar con tu correo electrónico y contraseña. (Ve a www.plex.tv para registrarte previamente si quieres usar este último)

Luego nos ofrece información de si queremos adquirir plex pass que nos ofrece una suscripción con ventajas adicionales. Esto es opcional y si no os interesa simplemente cerrar la ventana. 

Luego tenemos que configurar el nombre del servidor.  Puedes ponerle el nombre que quieras en mi caso lo llamaré igual que mi equipo en la red goolkeeper. También aparece la opción de "Permitir acceder a mis medios fuera de mi casa" que por defecto está habilitado. Como lo voy a utilizar para conectarme solo en casa desmarcaré esta opción. 

La siguiente página te da la opción de agregar a la biblioteca un directorio de medios. Como ya hemos creado previamente una carpeta compartida, buscamos en el directorio que se nos ofrece y la seleccionamos. (Apestosa en mi caso) Después le damos a Añadir a la Biblioteca. Y ya debería estar.

Si ahora en cualquier dispositivo que este conectado a la red (smartTV, ordenador, tableta, teléfono etc) navegamos a PLEX TV (www.plex.tv/es/ ) y le damos a open plex

ya podremos ver cómodamente lo que tengamos metido en ese directorio al estilo Netflix o Amazon prime.

En otro capítulo describiré más en detalle como configurarlo y su funcionamiento.