Saltar a contenido

Publicaciones

  • en Linux
  • 5 minutos de lectura

Escuchando música con MPD y ncmpcpp

¿Cuántos de nosotr@s nos hemos hecho esta pregunta? ¿Qué sería de la vida sin música? ¿Qué sería de la vida sin letras de canciones que denuncien, que estimen, que compartan dolor, amor, qué irradien ira o revolución? ¿Qué solo contenga ritmo para hacer ejercicio físico sin problemas? ¿Cuándo estamos solos y afligidos, cuándo queremos compartir momentos de celebración? Parece mentira pero la música nos despierta y nos anima. Pero más nos anima si la escuchamos haciendo uso del mínimo de recursos posibles sin perder calidad. Entonces, eso es amor.

Después de esta reflexión que parece sacada de un capítulo de Anatomía de Gray, vamos a proceder instalar el servidor de audio MPD, conocido como Music Player Daemon junto con el cliente ncmpcp(1) con el que interactuaremos cuando queramos escuchar música.

MPD es un servidor de audio que permite no solo escuchar música en local soportando multitud de códecs de audio como Ogg Vorbis, FLAC, Opus, WavPack, MP2, MP3, MP4/AAC, Mod..., si no que también puede transmitirla via streamming por el protocolo HTTP capaz de reproducir ficheros MP3 y OGG Vorbis. En suma, se puede gestionar el servidor a través de la red tanto por IPv4 como por redes IPv6, lee meta-información como las etiquetas ID3v1 y ID3v2, comentarios en Vorbis, MP4...; soporta reprodución contínua, una vez para de reproducirse una, se añaden unos segunos para "hacer creer" que sigue siendo un solo archivo (crossfading) y un millar de características más que si las seguimos mencionando no acabamos.

Instalación

Aquí añadimos varias formas de instalarlo en diferentes distribuciones, vamos a llevarlo a cabo en todas que utilicen systemd(1) junto con pulseaudio(1).

NOTA: Hay distribuciones que por licencias privativas, no se incluye software privativo de manera oficial como es el caso de Fedora, así que revisen que códecs son necesarios para nuestro sistema después de instalar el servidor y posteriormente el cliente con el que nos conectaremos.

Fedora

Para instalar en Fedora con ejecutar el siguiente comando se nos instalará pero no olvidemos instalar posteriormente los códecs para formatos MP3 desde los repositorios RPM Fusion:

sudo dnf install mpd

Ubuntu

En Ubuntu, vale tanto aptitude como la suite apt(1), hay que tener habilitado los repositorios Universe.

sudo apt-get install mpd

Debian

Como en Ubuntu, pero se encuentra en repositorio stable:

sudo apt-get install mpd

Archlinux

Tenemos que tener habilitado el repositorio extra:

sudo pacman -S mpd

Gentoo

No nos olvidemos de aplicar las USE que queramos para que se instale con los códecs y características que queramos. Puedes ver la lista pulsando aquí

sudo emerge -av media-sound/mpd

openSUSE Leap 42.3

La instalación en openSUSE requiere que se habilite el repositorio multimedia:apps porque no se encuentra soportado en los repositorios principales.

CentOS 7

Es necesario habilitar los repositorios nux

sudo yum install mpd

Configuración

La configuración como hemos dicho, haremos uso de pulseaudio(1) y lo ejecutaremos mediante nuestro usuario para evitar utilizar el usuario root que explicaremos en siguientes post que es este usuario y por qué se encuentra en el sistema.

  1. Creamos los directorios para albergar las configuraciones, playlists...etc mkdir ~/.mpd/{database,playlists,logs}
  2. Copiamos el fichero de configuración de ejemplo que nos proporciona mpd. cp /etc/mpd.conf ~/.mpd/
  3. Editamos el fichero de configuración y tienen que estar descomentadas y editadas las siguientes líneas: music_directory "~/Music" playlist_directory "~/.mpd/playlists" db_file "~/.mpd/database/mpd.db" log_file "~/.mpd/logs/mpd.log" user "sincorchetes" auto_update "yes" audio_output { type "pulse" name "My Pulse Output" } filesystem_charset "UTF-8"$

Explicaremos qué quiere decir cada línea: 1. Es el directorio dónde tengamos almacenada la música que queramos escuchar. 2. El directorio dónde se almacenarán las listas de reproducción personalizadas. 3. Fichero en el cuál se alojará los registros de cada archivo de reproducción. 4. Fichero de registro 5. Nuestro usuario 6. Se actualizará MPD de forma automática cuando MPD detecte cambios en el directorio 7. Habilitando PulseAudio en MPD (líneas 7,8 y 9) 8. Soporte UTF-8

Ahora para probar esta configuración, bastará con correr el servidor apuntando al fichero.

mpd ~/.mpd/mpd.conf

Puede que nos aparezca un mensaje como este:

exception: bind to '0.0.0.0:6600' failed (continuing anyway, because binding to '[::]:6600' succeeded): Failed to bind socket: Address already in use

Comunicándonos que se está utilizando el puerto que usa MPD, no pasa nada, lo omitimos y listo.

ncmpcpp

En este apartado, instalaremos y explicaremos como utilizar el cliente.

Instalando el cliente

Hay varios clientes para utilizar MPD, incluyendo clientes gráficos, pero a nosotros personalmente nos agrada utilizar ncmpcpp(1) más que nada por gustos.

Fedora

Para añadirlo a este SO:

sudo dnf install ncmpcpp
CentOS 7

Hay que tener habilitado el repositorio de nux como hemos mencionado anteriormente:

sudo yum install ncmpcpp
Ubuntu

Hay que tener habilitado el repositorio universe

sudo apt-get install ncmpcpp
Debian

Con un solo comando:

sudo apt-get install ncmpcpp
Archlinux

Tenemos que tener habilitado el repositorio Community

sudo pacman -S ncmpcpp
Gentoo

No nos olvidemos de que tenemos que declarar las variables USE para soportar determinadas características.

sudo emerge -av media-sound/ncmpcpp
openSUSE

Desafortunadamente no hay cliente para openSUSE, hay que compilarlo.

Probando

Para probarlo tan solo tenemos que ejecutar ncmpcpp(1)

¿Cómo manejarnos?

Bueno ncmpcpp(1) se utiliza mediante las flechas de dirección y algunas teclas preconfiguradas como las que recogemos en la siguiente tabla.

Combinación de teclas Descripción
a Añade un tema a una lista de reproducción, ya puede ser nueva o actual
↑ Sube por los elementos
↓ Desciende por los elementos
Shift + ↑ Selecciona elementos hacia arriba
Shift + ↓ Selecciona elementos hacia abajo
[ Desciende por el álbum
] Asciende por el álbum
{ Asciende según el artista
} Desciende según el artista
Page Up Asciende muchos ítems
Pade Down Desciende muchos ítems
Insert Selecciona ítem
Enter Según en la vista, puede reproduci, ingresar en un directorio...etc
Espacio Según la vista, puede añadir un elemento a la lista de reproducción, actualizar las letras según cambie la canción, cambiar el tipo de visualización...
Delete Borra ítems de la lista, del buscador...
← Bajar el volumen, columna anterior, pantalla máster
→ Subir el volumen, siguiente columna...
TAB Siguiente vista
Shift + TAB Vista anterior
F1 Muestra la ayuda
1 Vista: Lista de reproducción
2 Vista: Buscador
3 Vista: Modo navegador de archivos
4 Vista: Interactuar con la biblioteca
5 Vista: Editor de listas de reproducción
6 Vista: Editor de etiquetas
7 Vista: Muestra los métodos de salida
8 Vista: Visualizador de música (no lo hemos incluído en este post)
= Vista: Muestra un reloj digital
@ Vista: Muestra la información del servidor
s Para la reproducción
p Pausa la reproducción
> Siguiente tema
< Tema anterior
Ctrl + h En el modo navegador de archivos, vuelve un directorio hacia atrás
Ctrl + h Repite la canción en modo reproducción
Backspace En modo navegador sube un directorio
Backspace En modo reproductor repite la canción
f Reproduce más rápido
b Rebovina
r Modo repetición
z Reproducción aleatoria
y Tiene múltiples funciones, buscador de canciones, detecto de cambios en etiquetas, comenzar a buscar...
Y Modo reproducción de una única canción
u Actualizar la DB

En fin hemos comentado medio archivo de atajos de teclado que viene por defecto. Puedes crearte uno propio creando el directorio ~/.ncmpcpp/bindings.

Fuentes

  • Archlinux ~ MPD
  • man packages
    • mpd.conf(5)
    • mpd(1)
    • ncmpcpp(1)
  • en Linux
  • 4 minutos de lectura

Fedora 28 liberada

Fedora como tal, vio la luz por primera vez el 6 de noviembre de 2003 por parte del Proyecto Fedora, ya que, al principio solo era un repositorio de software adicional retestado para el viejo sistema operativo de la multinacional líder en opensource y software libre Red Hat. Este repositorio fue creado por Warren Togami en el 2002 en la universidad de Hawaii como un proyecto universitario. Sin embargo, se hizo tan popular que lleguó a convertirse en un sistema operativo comunitario llamado Fedora Core y que, en 2007 pasó a llamarse Fedora.

Este utilizaba como logo un sombrero azul, ya que, la empresa Red Hat utiliza un sombrero de color rojo para su representación.

Características de Fedora

El Proyecto Fedora es una comunidad muy amplia que se encuentra alrededor de todo el mundo como muchas de las demás comunidades en el software libre. Esta difunde una serie de valores como colaborar activamente con los proyectos de software como por ejemplo GIMP, GNOME, Plasma (antes KDE) reportando errores via upstream facilitando sus correciones y adheriendo el código nuevo en los proyectos. De tal forma, que toda persona que utilice estos software que hemos mencionado acabe utilizando código de Fedora. También premia la introducción de las nuevas tecnologías tanto a nivel de desarrollo como el software GCC, Binutils, Go, Python... hasta pasar por Devops y administradores de sistemas incluyendo soporte para arquitecturas en auge como ARM64 (AArch64) para server, imágenes para s390x...etc. La tercera es tener una comunidad fuerte y amistosa en la que apoyarse, un buen compañerismo es clave no solo para el PF, si no para cualquier tipo de proyecto comunitario. Y por último, premian mucho la libertad y difunden software libre y de open source frente al software privativo ya que si se utiliza el privativo y no se da pie al conocimiento de las demás alternativas libres obligan al usuario al final a depender de software registrado en licencias restrictivas.

También es una de las comunidades que no suelen perderse eventos alrededor de todo el mundo sobre software libre como FOSDEM en Bélgica, LinuxCon en Barcelona (2012), DevCon... etc. Incluso, organizan macroeventos llamados Flock (antes FUDCon) dónde todos los colaboradores pueden tener un punto de encuentro y conocerse cara a cara.

Novedades

Fedora 28 contiene multitud de novedades que no nos podemos perder, ¡es un disparate! abarca todos los perfiles, usuarios finales, desarrolladores, DevOps, administradores de sistemas...

Arquitectura AArch64 para servidores

En esta nueva versión se facilitan imágenes de Fedora Server para esta arquitectura como DVDs para instalar, imágenes cloud en formato qcow2 (muy utilizado por el software emulador, Qemu) e imágenes Docker para gestionar contenedores.

Más info

Modularización de Anaconda

Anaconda es el instalador por excelencia de Fedora, hace unos pocos años que se reescribió completamente dando un aire de frescura haciéndolo más fácil e intuitivo que hace años atrás. Muchos de los módulos se dividirán en varias partes que se comunicarán con DBus mediante una API. El objetivo es proveer de un instalador que permita personalizarse, potenciarse añadiendo plugins, extensiones... y sobre todo más formas de probar que funciona.

Más info

Binarios anotados

Añade información extra a los binarios que hayan sido compilados con GCC. Esta información se puede utilizar por los scripts para comprobar varias características de ficheros como las opciones de refuerzo de seguridad (hardering) o posibles conflictos con ABI

Más info

Imágenes cloud y/o contenedores para s390x

Se facilitarán imágenes para esta arquitectura incluyendo las variantes de Fedora. Éstas estarán disponibles en formato qcow2 y raw.

Más info

Software modular

Fedora proveerá de una serie de repositorios de software y actualizaciones con versiones alternativas a las suministradas por los repositorios oficiales.

Más info

Ahorro de batería en portátiles

Se mejora la versión de Fedora Workstation para el consumo de la batería en ordenadores portátiles por defecto.

Más info

En cuánto a desarrollador

Tenemos una lista de software que se ha actualizado como:

  • Binutils 2.29.1
  • Boost 1.66
  • GCC 8.0.1
  • GHC 8.2.2
  • GNU C Lib 2.27
  • Ruby 2.5
  • Golang 1.10.1
  • Django 2.0.4
  • Java-openjdk-10.0.46
  • Erlang 20.3.2
  • PHP 7.2.4

Para usuarios finales

Fedora Mate personalizado{.size-full}

No nos olvidemos que tenemos una lista de novedades para aquellas personas que utilicen entornos de escritorio, entre ellas:

  • Sugar 0.112
  • GNOME 3.28.1
  • Plasma 5.12.4
  • MATE 1.20.0
  • Cinnamon 3.8.0
  • Enlightenment 0.22.3
  • XFCE 4.12.1
  • LXQt 3.1.0

Y un sin fin de más novedades que puedes revisar en el siguiente enlace

¿A qué esperas para probarlo?

Enlaces

Descarga Fedora de forma directa a través de los siguientes enlaces:

Accede a los enlaces de torrent desde aquí

¡A disfrutar!

Nota: La imagen de cabecera fue extraída del artículo "Announcing Fedora 28 en FedoraMagazine.org"

  • en Desarrollo
  • 5 minutos de lectura

Flask - Creando una mini aplicación

En este tutorial aprenderás a utilizar Flask. Flask es un web framework elaborado en Python que te permite crear aplicaciones web bastante sencillas, pero potentes ya que el potencial se lo das tu elaborando tu propio sistema de validación, tus propios métodos de conexión a bases de datos... etc porque no olvidemos que es un microframework y no tiene muchas cosas como quizás tendría un framework como Django que contiene muchas más herramientas y desarrrollo.

Este tutorial lo he hecho basándome en la documentación oficial, pero con toques personales, así evito reproducir contenido una y otra vez.

¿Qué necesito?

  • Tener Python 3.5 o superior instalado y PyPy
  • Aunque soporte 2.7, no es recomendable utilizar esta versión porque el 31 de diciembre del año pasado se dejó de mantener la rama 2.x
  • Una o varias tazas de café

¿Cómo empezar?

A mi modo de ver las cosas y para no mezclar, siempre es mejor que utilices un entorno virtual que no el propio entorno del sistema, es decir, para instalar Flask hay que descargar una serie de códigos que se instalarán en tu sistema. Sin embargo, con un entorno virtual, puedes instalar, eliminar... o lo que quieras hacer sin dañar la instalación de Python del sistema base, ya sea Fedora, CentOS...etc

Creando un entorno virtual

$ python3 -m venv proyecto_flask

Cuando se haya creado, entonces ejecutamos:

$ flask/bin/activate

Este script carga variables de entorno y rutas para que puedas trabajar con tu proyecto, si te fijas, en el prompt de la terminal ya no está mostrándose como "$", si no, "(proyecto_flask) $"

Instalando Flask

Para instalar Flask, con el entorno virtual activo:

(proyecto_flask) $ pip install flask

Esto es todo, ya lo tendremos instalado.

Creando la mini aplicación

Utilizamos de ejemplo este directorio: /home/sincorchetes/proyecto_flask, si utilizas otro, que me imagino que sí, adáptalo al que utilices, y crea un subdirectorio llamado app.

Crea un archivo vacio y llámalo core.py (puedes llamarlo como quieras si luego defines que cargue el nombre correcto) y añades el siguiente contenido.

app/core.py
from flask import Flask
proyecto = Flask(_name_)

@proyecto.route('/')
def hola_mundo():
  return 'Hola Mundo'
  • La primera línea, importará el módulo Flask.
  • La segunda, inicializamos un objeto llamado proyecto que tiene una clase Flask y que hace referencia a sí mismo.
  • En la tercera línea, @proyecto.route('/') estamos diciendo que cuando el visitante acceda a: http://pepitodelospalotes.es verá lo que se haya definido en la función de abajo.
  • En las últimas líneas, desarrollamos la lógica de la aplicación, con la función hola_mundo(), le decimos que cuando el visitante acceda a la página verá lo que hay dentro del return, que en este caso es Hola Mundo.

Guarda el archivo, abre una terminal y sitúate en el directorio de la aplicación.

export FLASK_APP=/home/sincorchetes/proyecto_flask/app/core.py && \
export FLASK_DEBUG=1 && \
flask run

La variables FLASK_APP, defines el core de la aplicación, FLASK_DEBUG permite activar el modo depuración que viene con ayuda para que nos muestre de dónde puede provenir los errores...etc y flask run levanta un servidor de desarrollo para que puedas ver los cambios sin tener que utilizar un servidor web como Nginx o Apache.

Una vez levantada la aplicación, si accedemos a http://localhost:5000 verás el Hola Mundo que has definido en el archivo core.py.

¿Cómo creo una página?

Como he dicho anteriormente, Flask permite crear aplicaciones web, esto no solo incluye la parte de backend que es dónde definimos la lógica de la aplicación, si no que también puedes crear la parte frontend, la parte de visible con la que el usuario interactuará.

Hay que crear el directoriotemplates para añadir las páginas .html

Una vez hecho esto, creas el archivo app/templates/index.html y le añades el siguiente contenido:

index.html
<!DOCTYPE html>
<html lang="es">
  <head>
    <title>Ejemplo de aplicación hecha en Flask</title>
  </head>
  <body>
    <div class="contenedor">
      <div class="titulo">
        <h1>¡Bienvenidos a mi página Web!</h1>
      </div>
      <div class="tareas">
        <p>¿Te gustan los perros y los coches? Esta es tú página ideal.</p>
      </div>
    </div>
  </body>
</html>

Actualiza el fichero core.py de tal modo que se quede así:

app/core.py
from flask import Flask, render_template
proyecto = Flask(_name_)

@proyecto.route('/')
def hola_mundo():
  return render_template('index.html')

He añadido render_template que permite renderizar contenido .html en el proceso de importar módulos y en la última línea llamamos al método cuyo valor es el archivo que has creado.

Verás una página como esta:

¿Cómo añado hojas de estilo o código JavaScript?

Hay crear un directorio llamado static tal que así:

(proyecto_flask) $ mkdir /home/sincorchetes/proyecto_flask/app/static

Dentro de él, añade todo el contenido CSS o JS que cargará la página, lo que suelo hacer, es crear un subdirectorio css y para las hojas de estilo y js para la lógica de eventos para el usuario.

Para llamarlo, bastará con importar el módulo url_for y luego referenciarlo en el index.html. core.py

from flask import Flask,render_template,url_for
app/templates/index.html
<head>
  <link rel="stylesheet" href="{{ url_for('static',filename='css/nombre_archivo.css) }}">
</head>
<body>
  <script src="url_for('static',filename='js/nombre_archivo.js) }}></script>
</body>

Con esto bastará, creamos un archivo en app/static/css/ejemplo.css y añade el siguiente código:

app/static/css/ejemplo.css
.body{
  font-family: Arial;
}
.contenedor {
  border-radius: 30px;
  padding:20px;
  background-color: #D3D7CF;
}
.titulo {
  text-align:center;
}
.tareas {
  background-color: white;
  border-radius: 30px;
  padding:10px;
}
.date {
    font-size: 0.4em;
    text-align: right;
    padding-left:40%;
}

Creamos un archivo llamado ejemplo.js que mostrará un cuadro de diálogo:

app/static/js/ejemplo.js
alert("Bienvenido usuario")
index.html
<!DOCTYPE html>
<html lang="es">
  <head>
    <title>Ejemplo de aplicación hecha en Flask</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='css/ejemplo.css') }}">
  </head>
  <body>
    <div class="contenedor">
      <div class="titulo">
        <h1>¡Bienvenidos a mi página Web!</h1>
        <hr>
      </div>
      <div class="tareas">
        <h2>Flask es un microframework web - <span class="date">Editado 19-09-2020 09:20:00 am</span></h2> 
        <p>En el siguiente artículo hablaré de las maravillas de Flask....</p>
      </div>
    </div>
    <script src="{{ url_for('static', filename='js/ejemplo.js') }}"></script>
  </body>
</html>

Cuando accedas a http://localhost:5000 vas a ver una página como esta:

No es que digas ¡como mola esta página!, simplemente es para que veas cómo se pueden crear rutas, cómo renderizar contenido .html desde el backend y cargar archivos css y js para la parte frontend de la aplicación.

En las próximas entregas, verás como trabajar con variables, listas...etc que se renderizarán en la página y con un toque más profesional en el diseño con Bootstrap.

  • en Sistemas
  • 5 minutos de lectura

Foreman una manera de supervisar y gestionar tus servidores

Foreman es una plataforma Open Source que permite administrar y gestionar servidores tanto virtuales como físicos y que también ayuda a la hora de realizar tareas automatizadas de una forma muy interactiva y fácil de utilizar. En este entrega vamos a ver cómo podemos desplegar e instalar Foreman en CentOS 8.

Instalando Foreman en CentOS 8

Antes de proceder, es aconsejable tomar un snapshot de nuestra máquina si es virtual, o hacer una copia de seguridad si es física o también hacer ambas cosas.

Paso previo

Hacemos una copia del fichero /etc/hosts

# cp -va /etc/hosts /etc/hosts.instalando_foreman

Editamos el archivo /etc/hosts y añadimos una línea al final referenciando el hostname de nuestro servidor y la ip, guardamos el archivo. NOTA: Si no sabes cuál es el hostname, puedes usar el comando hostnamectl, este te devolverá mucha información, pero solo te interesa aquella que ponga "Static hostname". Y para la ip, identifica que tarjeta tienes con el comando ip addr que esté conectada y accesible a tu red interna.

NOTA 2: Utiliza como nombre de host minúsculas o te dará un error como este:

The hostname contains a capital letter.

This is not supported. Please modify the hostname to be all lowercase. If needed, change the hostname permanently via the
'hostname' or 'hostnamectl set-hostname' command
and editing the appropriate configuration file.
(e.g. on Red Hat systems /etc/sysconfig/network,
on Debian based systems /etc/hostname).

If 'hostname -f' still returns an unexpected result, check /etc/hosts and put
the hostname entry in the correct order, for example:

  1.2.3.4 hostname.example.com hostname

The fully qualified hostname must be the first entry on the line
Your system does not meet configuration criteria

Si tienes este problema, basta con aplicar estos cambios:

# cp -va /etc/hostname /etc/hostname.cambio_hostname

Editas el nombre del hostname que quieras:

# hostnamectl set-hostname $(cat /etc/hostname)

Modificas el nombre del host que hayas puesto en /etc/hosts que hace referencia a tu host actual, cierras sesión en tu servidor, te vuelves a loguear y prosigues con la instalación.

Ejemplo:

127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6

192.168.1.122 myhostname.lan

Es importante este proceso o cuando realices el paso de la instalación de la plataforma te dará un error como este:

Unable to resolve forward DNS for your system blabla
Does not meet configuration criteria

Instalando el software necesario

Importamos la llave GPG de Foreman

# rpm --import https://yum.theforeman.org/releases/2.1/RPM-GPG-KEY-foreman

Instalamos los repositorios necesarios:

# dnf install -y https://yum.puppet.com/puppet-release-el-8.noarch.rpm 
# dnf install -y https://yum.theforeman.org/releases/2.1/el8/x86_64/foreman-release.rpm
# dnf install -y epel-release

Editamos la configuración de los repositorios

# cp -va /etc/yum.repos.d/foreman.repo /etc/yum.repos.d/foreman.repo.cambiar_version
# cp -va /etc/yum.repos.d/foreman-plugins.repo /etc/yum.repos.d/foreman-plugins.repo.cambiar_version
# sed -ie 's/el7/el8/g' /etc/yum.repos.d/foreman.repo /etc/yum.repos.d/foreman-plugins.repo
# sed -ie 's/2.0/2.1/g' /etc/yum.repos.d/foreman.repo /etc/yum.repos.d/foreman-plugins.repo

NOTA: Esto hay que hacerlo, porque la comunidad de Foreman no automatizó este proceso haciendo uso de variables en su repositorio...

Instalamos el software de Foreman

# dnf check-update && dnf install -y foreman-installer

Lanzamos la instalación de la plataforma

NOTA: Este proceso se demorará un poco más o un poco menos dependiendo de tu hardware físico.

# foreman-installer

Veremos información quee va actualizándose en la termianl y cuando termine, nos devolverá un mensaje como este:

Preparing installation Done                                           
foreman-rake upgrade:run finished successfully!
  Success!
  * Foreman is running at https://myhostname.lan
      Initial credentials are admin / WoFc7UX2Ycm4WkXp
  * Foreman Proxy is running at https://myhostname.lan:8443
  The full log is at /var/log/foreman-installer/foreman.log

Ya podemos acceder a la interfaz web de forma local que aunque es un logro, no nos interesa porque gestionar un portal web desde un navegador como lynx o elinks no es especialmente plato de buen gusto, por lo que, haremos la gestión desde nuestro equipo, pero antes hay que habilitar el acceso en el cortafuegos en el servidor. Por defecto una vez instalado, se crea un servicio llamado foreman.service que se habilita en el arranque sin que tengamos que hacer nada.

# firewall-cmd --add-port 443/tcp --permanent
# firewall-cmd --add-port 8443/tcp --permanent
# firewall-cmd --reload

Accedemos desde nuestro equipo por IP, si tienes un servidor DNS que ya te resuelve el hostname, pues accede a través de él.

https://192.168.1.172 (en mi caso)

Certificado inválido

Vemos que el certificado es inválido, esto suele ocurrir en los despliegues de los servicios que necesiten obligatoriamente un certificado SSL. Estos generan un certificado autofirmado haciendo mención al hostname, aunque intentes crear una entrada en tu /etc/hosts de tu máquina dónde gestionarás Foreman y hagas la traducción, como no hay ninguna entidad que pueda avalar la autoridad este certificado seguirá siendo invalido.

Certificado inválido

Pero si tienes un certificado validado con Let's Encrypt por ejemplo lo puedes gestionar más adelante.

Nos saltamos la validación y accedemos al portal:

Foreman Login

Insertamos las credenciales que nos devolvió la terminal una vez se instaló y vemos el inicio de la aplicación web y veremos este panel principal o dashboard bastante vistoso que podemos personalizar como queramos (dentro de lo que nos deje claro).

Panel principal

En él podemos ver los equipos registrados, su estado, los últimos eventos, gráficas... te recomiendo que la primera cosa que hagas sea cambiar la contraseña de tu usuario, accede a la parte superior derecha de la pantalla dónde dice "My Account", y aquí edites la contraseña:

Cambiar contraseña

Espero que os haya gustado este tutorial, en las siguientes entregas veremos como ir añadiendo hosts a nuestro inventario y cómo podemos trabajar con ellos.

  • en Linux
  • 2 minutos de lectura

QEMUzier - Gestiona máquinas virtuales en QEMU/KVM fácilmente

QEMUzier es un pequeño script licenciado bajo GPL v2.0 que he laborado para gestionar de forma muy sencilla máquinas virtuales con el software de emulación QEMU modificado para utilizarlo con KVM para obtener virtualización completa en Linux.

Por el momento está adaptado para utilizarlo en distribuciones Fedora.

Para poder instalarlo:

GitLab

git clone https://gitlab.com/sincorchetes/qemuzier

GitHub

git clone https://github.com/sincorchetes/qemuzier

Cuando ejecutemos el script, hará una comprobación de dependencias para saber si tenemos qemu-img instalado y luego nos preguntará que queremos hacer.

Registrarlo en Bash

Si no queremos estar accediendo cada vez al directorio para ejecutarlo, podemos hacer que Bash lo reconozca siempre.

Añadimos la ruta a nuestra ruta de entorno personalizada ubicada en .bash_profile

Añadimos la ruta dónde se ubique el directorio, por ejemplo: PATH=$PATH:$HOME/.local/bin:$HOME/Documents/qemuzier

Para ver que se ejecuta, ejecutamos bash dentro de una terminal de comandos ya instanciada y veremos una salida como esta.

Welcome to QEMUzier. Script to create a new VM easy
List of currently created VMs

Debian
Choose an options:
1) Run VM
2) Create VM
3) List VMs
4) Destroy VM
Choose one:

¿Qué nos ofrece este script?

Bueno básicamente es para un uso sencillo, crear una máquina virtual con disco duro en formato QCOW, red en modo NAT, y que arranque con una imagen .ISO.

Las imágenes .ISO se almacenan en la ruta que te crea el script al principio en $HOME/.qemuzier/.iso. Este script no utiliza ningún tipo de base de datos que verifique las máquinas virtuales. Simplemente o están creadas (con ello implica la creación de un directorio dentro de .qemuzier, o no).

¿De cara al futuro?

Se puede incluir un auto-checking de dependencias, y una adaptación a las distribuciones populares; la posibilidad de crear redes bridging, he incluso, dotarlo de una interfaz gráfica con Python y PyGTK.

¡Espero que le saquéis algún partido!

  • en Linux
  • 2 minutos de lectura

Gestionando aplicaciones por defecto en Linux

Una de las formas que tiene Linux es que es tan configurable y tan versátil que podemos hacer lo que queramos con él, en este artículo veremos cómo configurar las aplicaciones por defecto para abrir X tipos de archivos.

¿Aplicaciones por defecto?

Todos los archivos tienen un identificador que permiten saber que tipo de dato contienen como por ejemplo un archivo de audio, está compuesto por un tipo de fichero de audio ya sea MP3, OGG...

Cuando utilizamos un entorno de escritorio o un gestor de ventanas (ya que el sistema en "crudo" no utiliza los MIME types, hace uso de otros métodos), el servidor gráfico interactúa con una base de datos que contiene lo que se denominan MIME Types. Los MIME Types es un estándar que facilita la identificación de los tipos de archivos del sistema mediante una serie de atributos en la cabecera del archivo que permiten presentarlos correctamente.

Podemos ver esta lista en /usr/share/applications/mimeapps.list

[Default Applications]
application/x-dia-diagram=dia.desktop
text/x-vcard=evolution.desktop
text/directory=evolution.desktop
text/calendar=evolution.desktop
application/x-cd-image=gnome-disk-image-mounter.desktop
application/x-raw-disk-image=gnome-disk-image-writer.desktop
application/x-raw-disk-image-xz-compressed=gnome-disk-image-writer.desktop
image/x-compressed-xcf=gimp.desktop
image/x-xcf=gimp.desktop
image/x-psd=gimp.desktop
image/x-fits=gimp.desktop
[...]

Para crear nuestra propia lista de aplicaciones la podemos hacer mediante comando xdg-mime o creando el archivo directamente en ~/.config/mimeapps.list

Con xdg-mime

Esta herramienta la podemos encontrar dentro del paquete xdg-utils de nuestra distribución.

Añadir una aplicación por defecto:

xdg-mime default *.desktop mime_type

Por ejemplo, abrir ficheros PDF con el visor ligero de MuPDF.

xdg-mime default mupdf.desktop application/pdf

Manualmente

Editamos o creamos el fichero ~/.config/mimeapps.list con nuestro editor favorito y a la par viendo la DB de mime ubicada en /usr/share/applications/mimeapps.list

Referencias

  • en Linux
  • 12 minutos de lectura

Gestores de paquetes RPM

Como ya hemos hablado anteriormente sobre qué es un gestor de paquetes comenzaremos a ver cómo trabajar con este gestor de paquetería.

Historia y antecedentes

Los orígenes del gestor de paquetes RPM (Red hat Package Manager) se remonta en el año 1997. Cuando Marc Ewing, Erik Troan y el resto de desarrolladores de Red Hat lo sacaron como mejora de los gestores de paquetes que existían en aquella época como es el caso de: PMS (Package Management System) desarrollado por Rik Faith, Doug Hoffman y Kevin Martin para su distribución llamada BOGUS en el año 1993; o RPP (Red Hat Software Program Packages) que vio la luz en 1994 en las primeras distribuciones beta de las versión Red Hat Commercial Linux (RCL) y por último, en 1994 también, Ian Murdock fundador de la distribución Debian GNU/Linux, saca a la luz DPKG.

Notas adicionales

La Linux Standard Base propuso RPM como un sistema de paquetes estándar que debería formar parte de toda distribución Linux. La LSB ha definido multitud de directorios para mantener un estándar en cuanto configuraciones entre otras muchas más cosas. Sin embargo, muchas distribuciones no respetaron esta proposición, y se dedicaron a mantener su propio sistema de paquetería. RPM es ampliamente utilizado sobre todo por las distribuciones openSUSE, Red Hat * como RHEL, Oracle Linux, CentOS, Fedora, Mageia, OpenMandriva, ROSA Linux, PCLinuxOS...

Los objetivos de su diseño era ser fácil de utilizar; tener un enfoque orientado solo a paquetes; actualización de versión superiores de paquetes; llevar un seguimiento de las dependencias internas de los paquetes; capacidad de llevar a cabo consultas; verficación; soporte para múltiples arquitecturas y utilizar fuentes originales.

Facilidad de uso

No es necesario efectuar una compilación de código fuente de un software como por ejemplo:

tar zxf software_package
cd software_package
./configure
make
su
make install

Este proceso conlleva a realizar 6 pasos, de los cuáles, 3 de ellos (pasos 3,4,6) pueden dar origen a fallos de compilación por no haber dependencias que se encuentren resultas; fallos en el Makefile (script de compilación); parámetros inestables....etc

A esto, que sería:

wget ftp://servidor.com/pub/RPM/software.rpm
rpm -ivh software.rpm

Sin duda alguna, reduce de forma notoria la complejidad, y el tiempo, ya que, cuando se compila de código fuente, suele consumir muchos recursos de la máquina, pero sobre todo tiempo de compilación.

Enfoque sobre un sistema que sea orientado a paquetes

Comentamos que pueden manipularse y/o gestionarse cientos y miles de paquetes de forma simultánea. Mientras que eliminar paquetes con el viejo proceso que se ha utilizado antaño make unistall clean (cuando existía), había que ir, de directorio en directorio efectuando dicha desinstalación. Por lo que se vuelve una ardúa y costosa tarea.

Actualización de paquetes

En la que se elimina el paquete que ha sido previamente instalado reemplazándolo por el nuevo sin afectar a la estabilidad del sistema. Y por si los administradores poseen ficheros de configuración generales, estos quedan como están, así se evitan perder esos ficheros. Para efectuar una migración completa de los ficheros nuevos de configuración a los nuevos, se crean los famosos .rpmnew. Estos son los ficheros que acompañan a la actualización y que se tratan utilizando rpmconf -a.

Interdependencia de paquetes.

Estos poseen una información de seguimiento para saber que otros paquetes son necesarios, en caso de actualización, instalación o eliminación de software. Ya que puede haber software que precise de otros programas y estos, si no contuvieran esta información de seguimiento. Puede que no se lleguen a instalar y no funcionaría correctamente el software.

Capacidad de realizar consultas

Característica que forma parte del sistema de paquetes RPM. Este trabaja en conjunto con una base de datos llamada Berkeley DB en la que se almacena toda la información que tenga que ver con los paquetes que se encuentren instalados en el sistema, incluyendo si, añaden documentación.

Verificación de paquetes

Característica que evita que se mantengan ficheros corruptos instalados en el sistema. RPM contiene un conjunto de información como el tamaño y los permisos sobre cada uno de los ficheros que se han instalado en el sistema. Esto evita que sucedan errores garrafales que puedan desembocar problemas de fallo de memoria en los programas que se han instalado. Como por ejemplo, un administrador modifica un fichero y este lo desborda con código erróneo, aumentando drásticamente su tamaño. Esto puede detectarlo RPM con su base de datos.

Disponibilidad múltiples arquitecturas

RPM en suma, está portado a múltiples arquitecturas, no solo está para x86, x86_64. Se puede encontrar para procesadores DEC, SPARC, Motorola 68000, ARM...

Fuentes originales

Nosotros con RPM podemos encontrarnos 2 tipos de paquetes. Un paquete contiene el código fuente que suelen contener las letras SRC en mayúsculas; y otro paquete que contienen los binarios pre-compilados.

Aquellos paquetes que contienen el SRC, facilitan la vida a los desarrolladores, porque contienen todo lo necesario para llevar a cabo el proceso de empaquetación binaria.

Terminología y/o nomenclatura

Ahora comentaremos un poco qué terminología utiliza RPM en sus paquetes. La terminología nos sirve para identificar determinadas características y funcionalidades que tiene un paquete. Ya que este puede contener multitud de parámetros que nos puede ayudar para saber la arquitectura que utiliza; la versión y sobre todo que tipo de versión ya que puede incluir alguna característica fuera de lo común; nombre del paquete...etc

En RPM, nos podemos encontrar 2 tipos de paquetes en el siguiente ejemplo extraído de Fedora 24:

phpMyAdmin-4.6.3-1.fc24.noarch
phpMyAdmin.src
  • Identifica el nombre del paquete
  • Identifica la versión e incluyendo revisión, en caso de que tuviese
  • Identifica la versión de Fedora que se está utilizando
  • Identifica la arquitectura, o, si el paquete es un paquete que contenga código fuente.
  • Sistemas 64 bits y soporte 32 bits (multilib)

En caso de que utilices arquitectura 64 bits, en las distribuciones RPM es fácilmente instaurable una capa de compatibilidad para software de 32 bits. No hace falta más que instalar el software que se encuentre en su terminología i686, poco más hay que hacer aparte de satisfacer las dependencias de dichos paquetes.

Contenido de los paquetes .RPM

Como hemos dicho anteriormente, existen 2 tipos de paquete, binario y source. Vamos a ver la diferencia que aguarda cada uno de ellos y que contienen de una forma más visual.

.

├── phpMyAdmin-4.6.1-all-languages.tar.xz

├── phpMyAdmin-4.6.1-all-languages.tar.xz.asc

├── phpMyAdmin-config.inc.php

├── phpMyAdmin.htaccess

├── phpMyAdmin.nginx

└── phpMyAdmin.spec

Este es el contenido de un SRC. Como se puede apreciar, no incluye nada más que:

  • Código fuente comprimido en .tar.xz
  • Suma de verificación del tarball
  • Ficheros específicos de configuración del software phpMyAdmin
  • Fichero .SPEC que hablaremos de ello más adelante.

Sin embargo, si nos fijamos en el contenido de un paquete binario obtendremos la siguiente salida:

.

├── etc

│   ├── httpd

│   │   └── conf.d

│   │       └── phpMyAdmin.conf

│   ├── nginx

│   │   └── default.d

│   │       └── phpMyAdmin.conf

│   └── phpMyAdmin

│       └── config.inc.php

├── usr

│   └── share

│       ├── doc

│       │   └── phpMyAdmin

│       │       ├── ChangeLog

│       │       ├── DCO

│       │       ├── examples

│       │       │   ├── config.manyhosts.inc.php

│       │       │   ├── config.sample.inc.php

Podemos observar, como ya incluye directorios del sistema con sus respectos ficheros necesarios para su funcionamiento. Y no incluye nada de código fuente que precise de su compilación.

Gestionando paquetes

Dentro de lo que cabe en nuestro sistema, podemos hacer las funciones básicas de gestión de paquetes como es el caso de eliminar, instalar o reinstalar entre otras más.

Instalar un paquete, bastará con efectuar el comando:

$ rpm -ivh nombre_paquete.rpm
-i: Instala el paquete
-v: Añade información extra sobre el proceso de instalación
-h: Muestra un porcentaje en # sobre su instalación.
[root@keys0 sincorchetes]# rpm -ivh tcsh-6.19.00-10.fc24.x86_64.rpm 
Preparing...                          ################################# [100%]
Updating / installing...
   1:tcsh-6.19.00-10.fc24             ################################# [100%]

Reinstalar un paquete:

$ rpm -vh --reinstall nombre_paquete.rpm
--reinstall: Reinstala el paquete
-v: Añade información extra sobre el proceso de reinstalación
-h: Muestra un porcentaje en # sobre su reinstalación.

[root@keys0 sincorchetes]# rpm --reinstall -vh tcsh-6.19.00-10.fc24.x86_64.rpm
Preparing...                          ################################# [100%]
Updating / installing...
   1:tcsh-6.19.00-10.fc24             ################################# [ 50%]
Cleaning up / removing...
   2:tcsh-6.19.00-10.fc24             ################################# [100%]

Eliminar un paquete, ejecutaremos el comando:

$ rpm -evh nombre_paquete.rpm 
-e: Elimina un paquete.
-v: Añade información extra sobre el proceso de eliminación
-h: Muestra un porcentaje en # sobre su eliminación

[root@keys0 sincorchetes]# rpm -evh tcsh
Preparing...                          ################################# [100%]
Cleaning up / removing...
   1:tcsh-6.19.00-10.fc24             ################################# [100%]

Trabajar con la DB

Como hemos comentado, RPM utiliza un conjunto de base de datos, la cual utiliza Berkeley DB, que nos sirve para mantener toda la información de los paquetes que se encuentren instalado en nuestro sistema.

Los ficheros los podemos encontrar en /var/lib/rpm: * Basenames * Conflictname * __db.001 * __db.002 * __db.003 * Dirnames * Enhancename * Filetriggername * Group * Installtid * Name * Obsoletename * Packages * Providename * Recommendname * Requirename * Sha1header * Sigmd5 * Suggestname * Supplementname * Transfiletriggername * Triggername

Sin embargo, no nos vamos a parar en cada uno de ellos, nos podemos hacer una idea que contenido puede tener cada uno.

Vamos a llevar a cabo una serie de ejemplo para trabajar con esta base de datos para así, en algunos casos, no llevarnos un chasco * * * * * .

Consultar la información de un paquete, utilizamos:

$ rpm -q nombre_del_paquete
Salida de ejemplo: 
[sincorchetes@keys0 rpm]$ rpm -q libcaca## C99-0.28.beta19.fc24.x86_64

Como hemos visto, nos ha devuelto la información del paquete que se encuentra instalada en nuestro sistema, en este caso, Fedora 24.

sincorchetes@keys0 rpm]$ rpm -q openshot 
package openshot is not installed

Obtener el listado de todos los paquetes instalados en el sistema:

[sincorchetes@keys0 rpm]$ rpm -qa |less
pated-3.2-20.fc24.x86_p64
perl-XML-SAX-0.99-16.fc24.noarch
libuser-python-0.62-3.fc24.x86_64
dconf-editor-3.20.3-1.fc24.x86_64
teamviewer-11.0.57095-0.i686
libedit-3.1-14.20150325cvs.fc24.x86_64
mate-notification-daemon-1.14.1-1.fc24.x86_64
[...]

Utilizando el comando anterior, y una tubería, se pueden filtrar resultados. Muy válido cuando se quiere obtenr listado de muchos programas que contienen diferentes versiones instaladas como es el caso del kernel.

[sincorchetes@keys0 rpm]$ rpm -qa |grep kernel
kernel-debug-devel-4.6.4-301.fc24.x86_64
kernel-4.6.4-301.fc24.x86_64
kernel-debug-modules-extra-4.6.4-301.fc24.x86_64
kernel-devel-4.6.4-301.fc24.x86_64
[...]

Otra forma de filtrar, es utilizando rpm -qa --pipe "grep kernel"

Para saber en qué paquete se encuentra un determinado fichero incluido rutas simbólicas.

$ rpm -qf ruta_fichero
[sincorchetes@keys0 rpm]$ rpm -qf /bin/bash 
bash-4.3.42-5.fc24.x86_64

Si queremos saber la información de un paquete instalado:

$ rpm -qi nombre_paquete
[sincorchetes@keys0 sbin]$ rpm -qi bash
Name        : bash
Version     : 4.3.42
Release     : 5.fc24
Architecture: x86_64
Install Date: Sat 06 Aug 2016 09:51:46 AM WEST
Group       : System Environment/Shells
Size        : 6373152
License     : GPLv3+
Signature   : RSA/SHA256, Thu 19 May 2016 06:29:51 PM WEST, Key ID 73bde98381b46521
Source RPM  : bash-4.3.42-5.fc24.src.rpm
Build Date  : Tue 17 May 2016 03:25:18 PM WEST
Build Host  : buildvm-22.phx2.fedoraproject.org
Relocations : (not relocatable)
Packager    : Fedora Project
Vendor      : Fedora Project
URL         : http://www.gnu.org/software/bash
Summary     : The GNU Bourne Again shell
Description : The GNU Bourne Again shell (Bash) is a shell or command language interpreter that is compatible with the Bourne shell (sh). Bash incorporates useful features from the Korn shell (ksh) and the C shell (csh). Most sh scripts can be run by bash without modification.

Obteniendo listado de grupos de paquete. RPM puede alojar un listado de grupos de paquetes para automatizar la instalación de los mismos.

$ rpm -qg nombre_grupo
[sincorchetes@keys0 sbin]$ rpm -qg Development/Debuggers
lsof-4.89-4.fc24.x86_64
libunwind-1.1-11.fc24.x86_64
gdb-7.11.1-75.fc24.x86_64

Listando los ficheros que incluye un paquete instalado:

$rpm -ql nombre_paquete
[sincorchetes@keys0 ~]$ rpm -ql bash
/etc/skel/.bash_logout
/etc/skel/.bash_profile
/etc/skel/.bashrc
/usr/bin/alias
/usr/bin/bash
/usr/bin/bashbug
/usr/bin/bashbug-64
/usr/bin/bg
/usr/bin/cd
/usr/bin/command
/usr/bin/fc
[...]

Listando ficheros por paquete

$ rpm -q --filesbypkg bash
[sincorchetes@keys0 ~]$ rpm -q --filesbypkg bash 
bash                      /etc/skel/.bash_logout 
bash                      /etc/skel/.bash_profile 
bash                      /etc/skel/.bashrc 
bash                      /usr/bin/alias 
bash                      /usr/bin/bash
[...]

Obteniendo una lista con más información:

$ rpm -qlv bash
[sincorchetes@keys0 ~]$ rpm -qlv bash 
-rw-r--r--    1 root    root                       18 May 17 15:22 /etc/skel/.bash_logout 
-rw-r--r--    1 root    root                      193 May 17 15:22 /etc/skel/.bash_profile 
-rw-r--r--    1 root    root                      231 May 17 15:22 /etc/skel/.bashrc 
-rwxr-xr-x    1 root    root                       29 May 17 15:22 /usr/bin/alias 
-rwxr-xr-x    1 root    root                  1072056 May 17 15:22 /usr/bin/bash 
lrwxrwxrwx    1 root    root                       10 May 17 15:22 /usr/bin/bashbug -> bashbug-64
[...]

Listando ficheros de configuración de x paquete:

$ rpm -qc bash
[sincorchetes@keys0 ~]$ rpm -qc bash 
/etc/skel/.bash_logout 
/etc/skel/.bash_profile 
/etc/skel/.bashrc

Listando archivos de configuración con más información de salida:

 $ rpm -qcv bash
[sincorchetes@keys0 ~]$ rpm -qcv bash
-rw-r--r--    1 root    root                       18 May 17 15:22 /etc/skel/.bash_logout
-rw-r--r--    1 root    root                      193 May 17 15:22 /etc/skel/.bash_profile
-rw-r--r--    1 root    root                      231 May 17 15:22 /etc/skel/.bashrc

Listando los scripts dentro de un paquete:

rpm -q --scripts bash
[sincorchetes@keys0 ~]$ rpm -q --scripts bash
postinstall scriptlet (using <lua>):
nl        = '\n'
sh        = '/bin/sh'..nl
bash      = '/bin/bash'..nl
f = io.open('/etc/shells', 'a+')
if f then
  local shells = nl..f:read('*all')..nl
  if not shells:find(nl..sh) then f:write(sh) end
  if not shells:find(nl..bash) then f:write(bash) end
  f:close()
end
[...]

Obteniendo la hoja de cambios del paquete (Changelog):

$ rpm -q --changelog bash
[sincorchetes@keys0 ~]$ rpm -q --changelog bash
* Tue May 17 2016 Siteshwar Vashisht <svashisht@redhat.com> - 4.3.42-5
- Do not set terminate_immediately and interrupt_immediately while expanding tilda
  Resolves: #1336800
* Wed Feb 03 2016 Fedora Release Engineering <releng@fedoraproject.org> - 4.3.42-4
- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild
[... ]

Listar los paquetes que han sido instalados recientemente:

$ rpm -qa --last |head
[sincorchetes@keys0 ~]$ rpm -qa --last |head 
qemu-system-aarch64-2.6.0-5.fc24.x86_64       Sun 07 Aug 2016 12:09:07 AM WEST 
qemu-2.6.0-5.fc24.x86_64                      Sun 07 Aug 2016 12:09:07 AM WEST 
edk2-aarch64-20160418gita8c39ba-4.fc24.noarch Sun 07 Aug 2016 12:09:07 AM WEST 
qemu-system-ppc-2.6.0-5.fc24.x86_64           Sun 07 Aug 2016 12:09:05 AM WEST 
SLOF-0.1.git20160223-1.fc24.noarch            Sun 07 Aug 2016 12:09:04 AM WEST 
qemu-system-x86-2.6.0-5.fc24.x86_64           Sun 07 Aug 2016 12:09:04 AM WEST
[...]

Hay multitud de opciones y parámetros que se pueden combinar. Pero que los daremos más adelante.

Trabajando externamente con RPM y su base de datos.

Anteriormente, hemos mencionado que se puede realizar una base de datos de nuestras DB que mantiene RPM de una manera sencilla que no supone tanta complejidad. También podemos reconstruirla y restaurarla con tan solo varios comandos.

Para llevar a cabo una copia de seguridad, basta con efectuar los siguientes comandos:

# cd /var/lib
# tar cvf rpmdb.tar ./rpm
# gzip rpmdb.tar

Estos comandos crean un archivo tar de los ficheros que contienen el directorio rpm.

Reconstruir la DB

$ rpm --rebuilddb

Antes de ejecutarlo, siempre es bueno hacer una copia de seguridad. Ya que si, surgen problemas, y no se pueda regenerar la DB. Habrá que tirar de la copia de seguridad. Si el proceso va bien, el tamaño de la base de datos de "Packages" bajará un poco de peso al no contener entradas que antes si contenía pero por desinstalación de algún programa. Una vez se reconstruya "Packages" se comenzarán a actualizar el resto de bases de datos.

Crear una base de datos nueva

$ rpm --initdb

Trabajando con dependencias

Cada paquete .RPM suele contener una serie de dependencias que debe suplir, antes de efectuar una instalación correctamente. Para ello, podemos utilizar este potente gestor de paquetes y averiguar que .RPM necesitamos suplir.

[sincorchetes@keys0 ~]$ rpm -ivh openshot-2.0.7-3.fc24.noarch.rpm 
error: Failed dependencies:
    python3-httplib2 is needed by openshot-2.0.7-3.fc24.noarch
    python3-libopenshot is needed by openshot-2.0.7-3.fc24.noarch
    python3-qt5 is needed by openshot-2.0.7-3.fc24.noarch
    python3-qt5-webkit is needed by openshot-2.0.7-3.fc24.noarch

Tenemos que buscar las dependencias, bien en los repositorios oficiales e instalarlas manualmente RECOMENDADO SIEMPRE. O bien mediante portales como RPMForge o RPMpbone adecuada para tu distribución.

Ver dependencias de un paquete cuando lo queremos eliminar:

$ rpm -e nombre_paquete
[sincorchetes@keys0 ~]$ rpm -e bash
error: Failed dependencies: 
/bin/bash is needed by (installed) fedora-release-24-2.noarch 
/bin/bash is needed by (installed) nss-softokn-freebl-3.25.0-1.0.fc24.x86_64 
/bin/bash is needed by (installed) kmod-22-4.fc24.x86_64 
/bin/bash is needed by (installed) iproute-4.4.0-3.fc24.x86_64 
/bin/bash is needed by (installed) openssl-1:1.0.2h-1.fc24.x86_64

Si este paquete posee múltiples paquetes que dependen de él, no se efectuará el proceso de eliminación.

En definitiva, con RPM podemos hacer de todo, podemos llevar a cabo instalación de más de 100 paquetes simultáneamente, eliminarlos, reinstalarlos; hacer copias de seguridad de las bases de datos de este magnífico gestor, restaurarlas, exportarlas...; verificar la integridad de los archivos instalados en el sistema con un simple comando; listar todos aquellos que se encuentren instalados y como lidiar con sus dependencias. Las cosas básicas que uno debería saber cuando trabaja con este tipo de sistema de paquetes.

Referencias

  • Fedora Documentation
  • RPM5 doc
  • Red Hat Doc
  • Google
  • Wikipedia
  • Eni ediciones ~ LPIC
  • en Linux
  • 3 minutos de lectura

Instala otras versiones de software en CentOS

A veces se hace un poco complicado la opción de CentOS como servidor si no lo sabemos administrar. Ya que si nosotros queremos instalar nuevas versiones de PHP, MariaDB, MongoDB o que se yo, te resultará prácticamente imposible a menos que compiles el software directamente o bien hagas uso de repositorios externos tipo Remi, Webtatic en el que ya tienes que confiar que eso vaya bien.

Sin embargo, CentOS ha seguido la filosofía que tiene Redhat de tener un repositorio llamado "CentOS Software Collection" en el que nos permite tener varias versiones de lenguajes de programación como PHP, Ruby, Python...

Para que conozcamos un poco de donde puede venir el asunto, tenemos que explicar que Redhat posee su propio repositorio llamado "Redhat Software Collection". Es un repositorio de paquetes al que solo puede acceder personas con subscripción Redhat, lo bueno que tiene estos repositorios es que están incluidos en su soporte al cliente.

Instalando el repositorio

Necesitaremos tener el repositorio de CentOS habilitado llamado "extras" y posteriormente adherimos el nuevo repo con YUM:

sudo yum install centos-release-scl -y
sudo yum upgrade

Visualizando versiones

Si ejecutas el siguiente comando, podrás ver un listado con todos los paquetes que disponibles en el repositorio que acabas de añadir al sistema:

sudo yum list available |scl

¿Cómo instalar los paquetes?

Para instalarlos basta con hacer un yum...

sudo yum install rh-php71

¿Cómo ejecutar un binario?

Una vez instalado el PHP de este repositorio, tenemos que tener en cuenta, que no se va a instalar en el directorio dónde se encuentran todos los ejecutables, documentación...etc del sistema. Si no que se creará un directorio en /opt/rh/NOMBRE_PAQUETE y no se modificará ningún .bashrc para añadir un alias, si quieres hacerlo, tendrás que hacerlo a mano.

No obstante, cuando instalamos por primera vez un software de este repositorio se nos viene como dependencia un paquete llamado scl-utils, que nos permitirá trabajar con los ejecutables de las diferentes versiones tal que así:

scl enable rh-php71 "php -a"

Y nos abrirá una consola lista para poder trabajar con el PHP recién instalado.

Ejecutando una shell

¡Pero! ¡No te mortifiques! También puedes cargar una shell bash que te permite cargar todo lo necesario (ruta de los binarios...) si ejecutas:

scl enable rh-php71 bash

Y lanzas un env verás como te carga los PATH necesarios para trabajar con soltura.

Servicios

Los servicios por lo general si que se instalan en el directorio que toca, en este caso es: /usr/lib/systemd/

  • Puedes habilitarlo si ejecutas:
sudo systemctl enable rh-mariadb102-mariadb.service
  • O deshabilitarlo al arranque:
sudo systemctl disable rh-mariadb102-mariadb.service
  • Iniciar el servicio
sudo systemctl start rh-mariadb102-mariadb.service
  • Parar el servicio
sudo systemctl stop rh-mariadb102-mariadb.service
  • Reiniciar el servicio
sudo systemctl restart rh-mariadb102-mariadb.service

¿Qué pasa si no recuerdo lo que instalé?

Con el comando scl podemos listar todos los paquetes instalados de la colección de software:

scl -l
rh-php71

Extras

Este repositorio también se puede utilizar en "containers", un concepto que verás más adelante, y también es posible reconstruir los paquetes de estas versiones con un comando llamado cbs que verás en otra ocasión.

Recursos

  • en Linux
  • 10 minutos de lectura

Instalando Docker en CentOS 8

¿Te imaginas tener un sistema que te permitira probar aplicaciones sin tener que desplegar máquinas virtuales? Ese proceso tan engorroso de tener que estar descargando una .iso, esperar a que descargue, crear la máquina virtual, instalarla, actualizarla, buscar las dependencias... todo ese proceso engorroso que te afecta si lo único que quieres probar es tu aplicación.

Pues hay una alternativa, y esa alternativa es Docker. Docker es un gestor de despliegue de contenedores que te permite ejecutar con un tamaño muy reducido comparado con el de una máquina virtual tu aplicación en un par de segundos y de forma aislada de tu sistema haciendo uso de un servicio.

"Docker"

Conceptos básicos

Vamos a explicar unos cuántos conceptos básicos, no te preocupes si hay algunas cosas que no entiendas, lo iré explicando en entregas posteriores.

¿Contenedor? ¿Qué es eso?

Un contenedor es la unidad de Docker, los contenedores son imágenes que se han desplegado y que están ocupando una serie de recursos de tu sistema para que puedan funcionar. Estos pueden contener software adicional que es añadido por un particular, empresa o proyecto que elabore esas imágenes.

¿Qué es una imagen?

Una imagen contiene un nombre único y un sistema base Linux mínimo para que pueda ejecutarse así mismo, ésta imagen utiliza un sistema de archivos llamado overlay2 que utiliza capas como mecanismo de control de cambios. Éstas capas se van añadiendo en el proceso de construcción de una imagen. Un ejemplo más cercano y no muy bien explicado, sería, instalar un sistema mínimo de alguna distribución de Linux (da igual cual sea), comprimimos todo el sistema con un .tar.gz y ya tendríamos nuestra imagen. Después, vas añadiendo más información en este .tar.gz, esto sería una capa nueva en una imagen de Docker.

¿Quién construye las imágenes?

Las imágenes suelen construirse por un particular, una empresa, una organización...o espera... ¡Tú también puedes hacerlo! más adelante explicaremos cómo lo puedes hacer.

¿Los contenedores se ejecutan de forma aislada?

Sí, los contenedores son como cajas de arena con las que puedes jugar sin afectar a tu propio sistema, ¡eso es lo bueno que tiene! Podemos desplegar un servidor Web NGINX con PHP incorporado y un sistema gestor de base de datos como es MariaDB ¡en segundos! ¡Nos dejamos de instalar esas engorrosas máquinas virtuales!

¿Se pueden definir límites de recursos del sistema por contenedor?

Sí, podemos decirle a los contenedores que no superen los recursos que le podemos asignar como es la memoria o el CPU entre otras cosas. También lo veremos más adelante.

¿Los contenedores son efímeros?

Sí, los contenedores pueden desaparecer y todo lo que haya dentro de elimina, por lo que si tu aplicación necesita guardar los archivos en algún sitito, es mejor que creas un volumen persistente.

¿Qué son los volúmenes persistentes?

Son como "particiones" de disco que podemos montar en nuestro contenedor o contenedores y permiten guardar archivos en ellos. Éstos se almacenan en un directorio del sistema.

¿Se puede usar un directorio del sistema como volumen persistente?

Sí, podemos usar un directorio actual cómo /home/sincorchetes/Descargas y montarlo como un volumen persistente en el contenedor, esto provocará que los archivos se guarden ahí.

Si los contenedores se ejecutan de forma aislada, ¿Cómo podemos acceder a ellos?

Se puede acceder, al instalar Docker en tu sistema, se crea una nueva interfaz en modo puente llamada docker0 y ademñas se crean unas rutas estáticas para llegar a esta red. Ésta interfaz de red suele tener una ip 172.17.0.1/16 y si ejecutamos un contenedor de Docker por defecto, éste contenedor se ejecutará utilizando esta red con la que podremos acceder a él si exponemos sus puertos. Es como cuando queremos acceder desde fuera al router de nuestra casa, exponemos el puerto 80 en el firewall y podemos acceder. Algo similar.

Cuando lo instalemos, ejecutamos nmcli, podemos ver como está en modo bridge por software:

docker0: connected to docker0
        "docker0"
        bridge, 02:42:BE:58:51:06, sw, mtu 1500
        inet4 172.17.0.1/16
        route4 172.17.0.0/16
        inet6 fe80::42:beff:fe58:5106/64
        route6 fe80::/64
        route6 ff00::/8

Y podemos ver la ruta estática que se crea con el comando ip addr:

default via 192.168.1.1 dev enp0s3 proto dhcp metric 100 
172.17.0.0/16 dev docker0 proto kernel scope link src 172.17.0.1 linkdown 
192.168.1.0/24 dev enp0s3 proto kernel scope link src 192.168.1.167 metric 100

Por otro lado, podemos acceder a la shell del contenedor mediante comandos que veremos más adelante, por lo que tenemos acceso a la gestión interna del contenedor por consola y acceso a las aplicaciones expuestas por puertos.

¿Puertos? ¿Redes? ¿Pueden los contenedores tener otras redes?

Sí, los contenedores podemos exponerlos o no para poder acceder a las aplicaciones que se ejecutan dentro, es decir, si tienes un servidor Web NGINX escuchando las peticiones en el puerto 80 (como es habitual), le tienes que decir que acepte peticiones desde fuera de esta red, por lo que estamos exponiendo ese contenedor hacia fuera mediante unos puertos específicos. Esto lo explicaremos más adelante.

Y sí, en Docker hay tres tipos de red que se pueden utilizar, una interfaz puente, una red aislada, o una red interna, ¡se pueden hacer maravillas! Pero este contenido se me escapa de las manos.

Pero... espera. ¿De dónde se sacan las imágenes?

Docker tiene la capacidad de buscar las imágenes dentro de un "Registry". Un "Registry" es un servidor o conjunto de servidores que nos ofertan múltiples imágenes y que también podemos interactuar con él (o ellos) como por ejemplo subir|eliminar|descargar las imágenes que hemos construido (si tenemos permisos para hacerlo).

Las imágenes contienen unas etiquetas que podemos especificarle o no (tags) éstas identifican la versión mayor, menor o si es la última versión liberada. Cada vez que se añadan capas nuevas o se modifique el contenido de una imagen, ésta se actualizará con un etiqueta nueva. Si no especificamos la etiqueta nueva, la última imagen que haya en el "registry" local no tendrá la etiqueta latest, la imagen que se descarga sí que la contendrá.

Por defecto Docker conecta con DockerHub y consulta las imágenes ahí.

Entonces el proceso de despliegue de una imagen es de la siguiente manera:

Entonces... ¿Quiere decir que tenemos un Registry en nuestro sistema?

¡Sí! lo tendremos. Cuando descargamos la imagen, ésta se descarga por defecto en un directorio llamado /var/lib/docker/, cuando queramos desplegar una imagen la buscará aquí primero antes de tirar de otro registry.

¡Muy bien! ¿Podemos empezar?

¡Pues claro!

Instalando Docker en CentOS 8

Primero quiero hacer una puntualización, Red Hat y las distribuciones como Fedora y CentOS están recomendando utilizar Podman. Podman es también un sistema de gestión de despliegues de contenedores muy parecido a Docker pero que utiliza un aislamiento mucho más estricto ya que dicen que el que Docker utiliza un servicio para gestionarlo todo es un agujero muy grande de seguridad y tiene razón, Docker tampoco es compatible con la nueva versión de cgroups. Los cgroups conocidos como "Control Groups" es una colección de procesos que están balanceados y están asociados con un conjunto de parámetros o límites. Estos grupos pueden ser jerárquicos refiriéndose a que cada grupo hereda los límites de su grupo padre. El núcleo accede a los múltiples controladores (también llamados subsistemas) a través de un interfaz cgroup; por ejemplo, el controlador de la "memoria" limita el uso de la memoria, "cpuacct" el uso de las cuentas de CPU...

Por lo visto, se reescribió la versión de CGroup en su segunda versión, y tanto CentOS 8 como Fedora usan la versión 2 que no está soportada por Docker. Para ello tenemos que añadir la siguiente línea en la línea del núcleo.

Habilitando cgroup v1

Hacemos una copia de seguridad de este archivo:

# cp -va /etc/default/grub /etc/default/grub.bck.$(date +%d-%m-%y_%H_%M)

Editamos el archivo y añadimos al final de la variable GRUB_CMDLINE_LINUX=

systemd.unified_cgroup_hierarchy=0

Por ejemplo, en mi máquina lo tengo así:

GRUB_CMDLINE_LINUX="crashkernel=auto resume=/dev/mapper/cl_docker--server-swap rd.lvm.lv=cl_docker-server/root rd.lvm.lv=cl_docker-server/swap rhgb quiet systemd.unified_cgroup_hierarchy=0"

Regeneramos el fichero de configuración de arranque:

  • Si usas UEFI, este estará en:
# grub2-mkconfig -o /boot/efi/EFI/centos/grub.cfg
  • Si usas MBR:
# grub2-mkconfig -o /boot/grub2/grub.cfg

Reiniciamos el sistema.

Instalando Docker-CE

CentOS no posee una versión de Docker por lo que hemos comentado más arriba. Siguiendo parte de la documentación oficial, instalaremos la versión estable y comunitaria mediante los repositorios oficiales de Docker-CE (Community Edition).

# dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# dnf config-manager --enable docker-ce-stable
# dnf check-update
# dnf install docker-ce docker-ce-cli containerd.io --nobest

Como curiosidad podemos ver las múltiples versiones disponibles que podemos instalar:

$ dnf list docker-ce --showduplicates | sort -r
Installed Packages
docker-ce.x86_64            3:19.03.8-3.el7                    docker-ce-stable 
docker-ce.x86_64            3:19.03.7-3.el7                    docker-ce-stable 
docker-ce.x86_64            3:19.03.6-3.el7                    docker-ce-stable 
docker-ce.x86_64            3:19.03.5-3.el7                    docker-ce-stable 
docker-ce.x86_64            3:19.03.4-3.el7                    docker-ce-stable 
docker-ce.x86_64            3:19.03.3-3.el7                    docker-ce-stable 
docker-ce.x86_64            3:19.03.2-3.el7                    docker-ce-stable 
docker-ce.x86_64            3:19.03.1-3.el7                    docker-ce-stable 
...

Arrancando los servicios de Docker

# systemctl start docker.service

Revisamos que se está ejecutando correctamente:

$ sudo systemctl status docker.service

● docker.service - Docker Application Container Engine
   Loaded: loaded (/usr/lib/systemd/system/docker.service; disabled; vendor pre>
   Active: active (running) since Sun 2020-05-03 18:09:57 CEST; 3s ago
     Docs: https://docs.docker.com
 Main PID: 25800 (dockerd)
    Tasks: 17
   Memory: 49.6M
   CGroup: /system.slice/docker.service
           ├─25800 /usr/bin/dockerd -H fd://
           └─25809 containerd --config /var/run/docker/containerd/containerd.to>

Ya que vemos que funciona, lo dejamos habilitado al arranque de la máquina:

$ systemctl enable docker.service

Probamos a correr un contenedor hello-world de Docker:

 # docker run hello-world

Como explicamos anteriormente, como la imagen hello-world no está en nuestro registry local, va a buscarla a Docker Hub por defecto, la descargará y luego creará el contenedor. Esta es la salida correcta: ``` Unable to find image 'hello-world:latest' locally latest: Pulling from library/hello-world 0e03bdcc26d7: Pull complete Digest: sha256:8e3114318a995a1ee497790535e7b88365222a21771ae7e53687ad76563e8e76 Status: Downloaded newer image for hello-world:latest

Hello from Docker! This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps: 1. The Docker client contacted the Docker daemon. 2. The Docker daemon pulled the "hello-world" image from the Docker Hub. (amd64) 3. The Docker daemon created a new container from that image which runs the executable that produces the output you are currently reading. 4. The Docker daemon streamed that output to the Docker client, which sent it to your terminal.

To try something more ambitious, you can run an Ubuntu container with: $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID: https://hub.docker.com/

For more examples and ideas, visit: https://docs.docker.com/get-started/ ```

¡Con esto ya habremos acabado!

NOTA: _Si quieres simplificar el proceso de administración en un servidor de pruebas, puedes añadir tu usuario al grupo docker para que no solicite privilegios, pero esto se considera un fallo de seguridad ya que puedes escalar privilegios. Así que cuidado. # usermod -aG docker your-user

Comandos de Docker

Si ejecutamos el comando docker a secas, veremos una lista enorme de opciones que podemos utilizar. Por un lado tenemos las opciones de gestión:

  builder     Manage builds
  config      Manage Docker configs
  container   Manage containers
  context     Manage contexts
  engine      Manage the docker engine
  image       Manage images
  network     Manage networks
  node        Manage Swarm nodes
  plugin      Manage plugins
  secret      Manage Docker secrets
  service     Manage services
  stack       Manage Docker stacks
  swarm       Manage Swarm
  system      Manage Docker
  trust       Manage trust on Docker images
  volume      Manage volumes

Y por otro lado, tenemos comandos:

  attach      Attach local standard input, output, and error streams to a running container
  build       Build an image from a Dockerfile
  commit      Create a new image from a container's changes
  cp          Copy files/folders between a container and the local filesystem
  create      Create a new container
  deploy      Deploy a new stack or update an existing stack
  diff        Inspect changes to files or directories on a container's filesystem
  events      Get real time events from the server
  exec        Run a command in a running container
  export      Export a container's filesystem as a tar archive
  history     Show the history of an image
  images      List images
  import      Import the contents from a tarball to create a filesystem image
  info        Display system-wide information
  inspect     Return low-level information on Docker objects
  kill        Kill one or more running containers
  load        Load an image from a tar archive or STDIN
  login       Log in to a Docker registry
  logout      Log out from a Docker registry
  logs        Fetch the logs of a container
  pause       Pause all processes within one or more containers
  port        List port mappings or a specific mapping for the container
  ps          List containers
  pull        Pull an image or a repository from a registry
  push        Push an image or a repository to a registry
  rename      Rename a container
  restart     Restart one or more containers
  rm          Remove one or more containers
  rmi         Remove one or more images
  run         Run a command in a new container
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
  search      Search the Docker Hub for images
  start       Start one or more stopped containers
  stats       Display a live stream of container(s) resource usage statistics
  stop        Stop one or more running containers
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
  top         Display the running processes of a container
  unpause     Unpause all processes within one or more containers
  update      Update configuration of one or more containers
  version     Show the Docker version information
  wait        Block until one or more containers stop, then print their exit codes

En los siguientes tutoriales veremos como utilizar los comandos de gestión de Docker.

  • en Linux
  • 16 minutos de lectura

Instalando Gentoo con LVM,LUKS y SELinux

Hemos hablado una vez de Gentoo en un post anterior, por lo que voy a ir más al grano en este post sobre cómo lo he conseguido instalar y cómo ayudarte si tienes dudas haciéndolo. Te recomiendo que si no tienes una pantalla dónde puedas consultar la información de este post, que utilices un medio live que te permita interactuar con todos estos pasos, porque es muy importante que no te pierdas al llevar a cabo este post. También es importante TENER TIEMPO para hacer esta instalación y no esperes que este proceso se hace en un par de horas. Se compilará mucho código fuente y este proceso ES COSTOSO en todos sus aspectos, por lo que te recomiendo QUE NO HAGAS muchas compilaciones a la vez.

Consideraciones

  • Configurar la BIOS de tu equipo para que arranque en modo UEFI y sin tener activado el secure boot.
  • Tener mucho tiempo libre y pensar las cosas antes de ejecutarlas
  • Tener un tazón y una cafetera enorme de café al lado.
  • Tener un buen respaldo en la silla y tiene que ser cómodo, nada de taburetes de 100 montaditos

Hardware que utilicé

Estas son algunas de las especificaciones de Hardware con los que hice la instalación: * BIOS configurada para arrancar con UEFI sin secure boot. * Modelo: Portátil Gigabyte Sabre 15 * Procesador: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz * Memoria RAM: Kingston 8GB 64 bits 2400MHz * Disco NVME: Western Digital Black HD 2018 256GB * Audio integrado: Intel CM238 HD Audio Controller * Gráfica integrada: Intel HD Graphics 630 * Gráfica dedicada: NVIDIA GP107M GeForce GTX 1050 Mobile * Audio dedicado: NVIDIA GP107GL High Definition Audio Controller * USB con espacio mínimo de 4GB

Creando un live

En mi caso, como prefiero ver vídeos, distraerme y ver la documentación bien y de forma clara, prefiero realizar este proceso desde una imagen live con un entorno de escritorio como es Calculate Linux antes de utilizar la imagen que Gentoo libera para la instalación que es todo en terminal. No obstante, si quieres, puedes utilizar los siguientes comandos que utilicé para generar el pendrive con Calculate Linux para crearte tu pendrive con la imagen de Gentoo.

Siguiendo la documentación de Calculate Linux, insertamos el USB. Ejecutamos dmesg veremos cuál es el pendrive reconocido en el sistema:

$ dmesg
[ 6451.987041] usb 1-11: new high-speed USB device number 6 using xhci_hcd
[ 6452.167412] usb 1-11: New USB device found, idVendor=0951, idProduct=1666, bcdDevice= 1.00
[ 6452.167417] usb 1-11: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[ 6452.167421] usb 1-11: Product: DataTraveler 3.0
[ 6452.167424] usb 1-11: Manufacturer: Kingston
[ 6452.167426] usb 1-11: SerialNumber: 002618A369C3B1A0B7AC022F
[ 6452.168867] usb-storage 1-11:1.0: USB Mass Storage device detected
[ 6452.169331] scsi host3: usb-storage 1-11:1.0
[ 6453.203673] scsi 3:0:0:0: Direct-Access     Kingston DataTraveler 3.0 PMAP PQ: 0 ANSI: 6
[ 6453.204285] sd 3:0:0:0: Attached scsi generic sg1 type 0
[ 6453.204565] sd 3:0:0:0: [sdb] 121110528 512-byte logical blocks: (62.0 GB/57.8 GiB)
[ 6453.205397] sd 3:0:0:0: [sdb] Write Protect is off
[ 6453.205403] sd 3:0:0:0: [sdb] Mode Sense: 2b 00 00 08
[ 6453.206361] sd 3:0:0:0: [sdb] Write cache: disabled, read cache: enabled, doesn't support DPO or FUA
[ 6453.241654]  sdb: sdb1 sdb2
[ 6453.244855] sd 3:0:0:0: [sdb] Attached SCSI removable disk

En mi caso, es el /dev/sdb, el cuál usaré de ejemplo.

  1. Descargamos una imagen de Calculate Linux
  2. Comprobamos que la suma de verificación para evitar que la imagen esté corrupta, el enlace para comprobar en MD5 o en SHA1 está justo al lado del enlace de descarga:

En mi caso, utilicé la imagen de Calculate Linux MATE 64 bits y con SHA1:

84ffa7fbce9c557b810f6204dd3e75b153aa5bf2  cldm-20-x86_64.iso

Comprobamos que sea el mismo hash:

$ sha1sum cldm-20-x86_64.iso
84ffa7fbce9c557b810f6204dd3e75b153aa5bf2

Está perfecta, y no está corrupta.

Generamos el pendrive live como dice la documentación:

# dd if=IMAGEN_CALCULATE.iso of=/dev/sdN
  • dd es un comando que permite copiar tal cual un archivo, y tiene múltiples usos entre ellos hacer imágenes live.
  • if ruta del archivo fuente
  • IMAGEN_CALCULATE nombre de la imagen
  • /dev/sdN el archivo dispositivo de bloques detectado por el SO
  • of ruta del archivo destino, no olvidemos que aunque hemos conectado un pendrive, este en Linux es un dispositivo de bloques y queda reflejado como si fuera un archivo.

En mi caso:

# dd if=cldm-20-x86_64.iso of=/dev/sdb

Reiniciamos el ordenador y arrancamos el SO del pendrive. Esperamos a que cargue el entorno de escritorio y estará la primera parte hecha.

Particionando

Particionamos el dispositivo, en mi caso es un SSD NVME que tiene otro conector diferente y el núcleo de Linux lo llama como /dev/nvme0n1.

Definimos el siguiente esquema de particionamiento:

Partición Pto montaje Formato Nombre Tamaño Bandera
/dev/nvme0n1p1 X FAT32 grub 2MB bios_grub
/dev/nvme0n1p2 /boot ext4 boot 512MB X
/dev/nvme0n1p3 /boot/efi FAT32 efi 128MB boot, esp
/dev/nvme0n1p4 * LVM rootfs * lvm

NOTA: Si tienes un disco sda|sdb|sdc... adáptalo como gustes.

Dentro del LVM, crearemos un grupo de volúmenes llamado gentoo, y dentro de él, crearemos un volúmen lógico para la swap, y le definiré un tamaño de 8GB porque suelo tirar mucho de ella, y crearemos otro volúmen lógico para root utilizando el resto de espacio libre.

NOTA: El primer * es un grupo de volúmen que haremos más adelante, y el segundo, todo el espacio libre restante.

Abrimos una consola, escalamos privilegios para tener acceso como root:

# parted -a optimal /dev/sdN
GNU Parted 3.2
Using /dev/sdN
Welcome to GNU Parted! Type 'help' to view a list of commands.

Creamos el esquema de particionamiento

(parted) mklabel
(parted) unit mib
(parted) mkpart primary 1 3
(parted) name 1 grub
(parted) set 1 bios_grub on
(parted) mkpart primary 3 512
(parted) name 2 boot
(parted) mkpart primary 512 640
(parted) name 3 efi
(parted) set 3 boot on
(parted) mkpart primary 640 -1
(parted) name 4 rootfs
(parted) quit

Ya tendremos nuestro esquema listo, ahora toca darle formato.

Creamos las particiones EXT4 y FAT32 para la partición EFI

# mkfs.ext4 /dev/nvme0n1p2
# mkfs.fat  -F 32 /dev/nvme0n1p3

Creamos la partición cifrada:

# cryptsetup luksFormat /dev/nvme0n1p3

Confirmamos en mayúsculas que si queremos (YES).

Descriframos la partición cifrada:

# cryptsetup luksOpen /dev/nvme0n1p3 world

Creamos el volúmen físico:

# pvcreate /dev/mapper/world

Creamos el grupo de volúmen:

# vgcreate gentoo /dev/mapper/world

Creamos los volúmenes lógicos:

# lvcreate -L 8G -n swap gentoo
# lvcreate -l100%FREE -n root gentoo

Formateamos los volúmenes lógicos:

# mkfs.ext4 /dev/mapper/gentoo-root
# mkswap /dev/mapper/gentoo-swap

Activamos la swap:

# swapon /dev/mapper/gentoo-swap

Creamos el directorio /mnt/gentoo:

# mkdir /mnt/gentoo

Montamos la partición raíz:

# mount /dev/mapper/gentoo-root /mnt/gentoo

Creamos la partición /boot y /boot/efi:

# mkdir /mnt/gentoo/boot
# mount /dev/nvme0n1p2 /boot
# mkdir /mnt/gentoo/boot/efi
# mount /dev/nvme0n1p3 /boot/efi

Hemos terminado el particionamiento, el formato y el montaje de los sistemas de archivos que hemos formateado.

Descargando e instalando el stage3

El stage3 es un conjunto de librerías y binarios precompilados por el grupo de desarrollo de Gentoo que está casi listo para utilizar. El stage2 y stage1 son para personas que quieren armarse Gentoo casi desde 0, no es recomendado hasta que lleves una cierta soltura con el sistema. Además, hay un stage4 que es un nivel más arriba de abstracción pero que nunca he probado.

Descargamos el stage3 de Gentoo hardened+selinux desde este espejo mismo. Si no va bien, hay una amplia lista de espejos que tiene Gentoo disponibles para probar.

Descargamos los archivos .tar.xz y .DIGESTS con wget situados en el directorio /mnt/gentoo

# cd /mnt/gentoo
# wget https://ftp-stud.hs-esslingen.de/pub/Mirrors/gentoo/releases/amd64/autobuilds/current-stage3-amd64-hardened-selinux/stage3-amd64-hardened-selinux-20200422T214502Z.tar.xz
# wget https://ftp-stud.hs-esslingen.de/pub/Mirrors/gentoo/releases/amd64/autobuilds/current-stage3-amd64-hardened-selinux/stage3-amd64-hardened-selinux-20200422T214502Z.tar.xz.DIGESTS

Nos fijamos en la suma de verificación SHA512 del stage3 en el .DIGESTS:

# cat stage3-amd64-hardened-selinux-20200422T214502Z.tar.xz.DIGESTS
# SHA512 HASH
0ac73366478b4c0ac2f35b1f19a64e8041f666a9f9afd2a67691f77e9ab67d6a8f672d740b2faeb8851c4095e54cdb04f3d6e08a262ce5135840db5ac5bf0181  stage3-amd64-hardened-selinux+nomultilib-20200422T214502Z.tar.xz

Comprobamos que es la misma que el stage3:

# sha512sum stage3-amd64-hardened-selinux-20200422T214502Z.tar.xz

Si es correcta, descomprimimos el tarball

# tar xpvf stage3-*.tar.xz --xattrs-include='*.*' --numeric-owner --selinux --acls

Configuraciones iniciales

Editamos el archivo /mnt/gentoo/etc/portage/make.conf

NOTA: En este archivo se define todo lo que tenga que ver con la compilación de los paquetes del sistema entre otras cosas.

Añadiendo optimización en la compilación

Y en la variables CFLAGS añadimos el parámetro -march=native. Este parámetro tomará de forma automática todas las instrucciones de tu procesador y lo compilará solo y exclusivamente para que esté soportado por él. Si tienes intención de portal el software a otras tipos de CPU, entonces no lo pongas.

NOTA: Las CFLAGS y otras variables permiten pasar una serie de instrucciones al compilador para que el código compilado en C y C++ sea más óptimo y reducido (o por lo menos eso es lo que se busca). Puedes leer más información en la documentación de Gentoo.

Y lo dejamos así por el momento, si en el futuro quieres añadir más parámetros o modificadores en el comportamiento de la compilación de los programas lo dejo a libre elección.

 These settings were set by the catalyst build script that automatically
# built this stage.
# Please consult /usr/share/portage/config/make.conf.example for a more
# detailed example.
COMMON_FLAGS="-march=native -O2 -pipe"
CFLAGS="${COMMON_FLAGS}"
CXXFLAGS="${COMMON_FLAGS}"
FCFLAGS="${COMMON_FLAGS}"
FFLAGS="${COMMON_FLAGS}"

Añadiendo los mirrors

Creamos una variable llamada GENTOO_MIRRORS="https://ftp.fau.de/gentoo" y añadimos este mirror, si quieres otro puedes añadirlo también consultando la lista de espejos aquí y seguidos de un espacio.

# echo 'GENTOO_MIRRORS="https://ftp.fau.de/gentoo"' >> /etc/portage/make.conf

Añadiendo soporte multihilo

Añadimos otra variable que se llama MAKEOPTS="-jN", dónde N equivale al número de CPUS que tienes + 1. Por ejemplo, en mi caso tengo 8, pues le asigno MAKEOPTS="-j9". ¿Cómo puedes ver la cantidad de CPU (CPU e hilos) que tienes? con el comando lscpu:

$ lscpu
Architecture:                    x86_64
CPU op-mode(s):                  32-bit, 64-bit
Byte Order:                      Little Endian
Address sizes:                   39 bits physical, 48 bits virtual
CPU(s):                          8******

El valor mostrado en el apartado CPU(s), es el que cuenta.

Configurando el repositorio de Gentoo

Creamos directorios necesarios para portage:

# mkdir --parents /mnt/gentoo/etc/portage/repos.conf

Creamos este archivo /mnt/gentoo/etc/portage/repos.conf/gentoo.conf y le añadimos:

[DEFAULT]
main-repo = gentoo

[gentoo]
location = /var/db/repos/gentoo
sync-type = rsync
sync-uri = rsync://rsync.gentoo.org/gentoo-portage
auto-sync = yes
sync-rsync-verify-jobs = 1
sync-rsync-verify-metamanifest = yes
sync-rsync-verify-max-age = 24
sync-openpgp-key-path = /usr/share/openpgp-keys/gentoo-release.asc
sync-openpgp-key-refresh-retry-count = 40
sync-openpgp-key-refresh-retry-overall-timeout = 1200
sync-openpgp-key-refresh-retry-delay-exp-base = 2
sync-openpgp-key-refresh-retry-delay-max = 60
sync-openpgp-key-refresh-retry-delay-mult = 4

Copiando los DNS a lo que será nuestro SO

Copiamos la información de los DNS

# cp --dereference /etc/resolv.conf /mnt/gentoo/etc/

Pasos previos a la instalación

Estos pasos son necesarios para poder continuar, hay que asegurarse de que todo está correctamente.

Montando los pseudos sistemas de archivos

Montamos los pseudosistemas de archivos necesarios para poder hacer un chroot:

root #mount --types proc /proc /mnt/gentoo/proc
root #mount --rbind /sys /mnt/gentoo/sys
root #mount --rbind /dev /mnt/gentoo/dev

NOTA: Estamos haciendo una "redirección" de estos pseudo sistemas de archivos para que podamos ejecutar comandos que interactúen con el hardware de nuestro equipo.

NOTA: Si haces la instalación con algún live que use systemd, tienes que ejecutar estos comandos adicionales, si no, ignora este paso:

# mount --make-rslave /mnt/gentoo/sys
# mount --make-rslave /mnt/gentoo/dev

NOTA: Si no utilizas el live de instalación de Gentoo como yo usando Calculate Linux, ejecuta los siguientes comandos como dice la documentación, de lo contrario omite este paso:

# test -L /dev/shm && rm /dev/shm && mkdir /dev/shm
# mount --types tmpfs --options nosuid,nodev,noexec shm /dev/shm
# chmod 1777 /

Accediendo a nuestro futuro sistema

El chroot permite "aislar" el sistema que vamos configurar del actual evitando accidentes, por lo que habrán variables, comandos y directorios que no existan, y lo que era /mnt/gentoo se volverà /. ¡Cuidado con no confundirse dónde estás trabajando!

# chroot /mnt/gentoo /bin/bash
# source /etc/profile
# export PS1="(chroot) ${PS1}"

NOTA: Ejecutamos un mount y tenemos que ver que las particiones /boot, /boot/efi se encuentren montadas, si no habrá que salir del chroot y montarlas de nuevo como en comento en los primeros pasos.

Configurando Portage

Portage es un conjunto de directorios bien organizados por categorías basadas en el criterio de los desarrolladores de Gentoo, y que cada una de ellas, hay un directorio con el nombre del software cuyo interior hay scripts como .ebuilds, parches...etc necesarios para instalar los paquetes.

Descargamos todos el árbol de portage para poder instalar software necesario.

# emerge-webrsync
# emerge --sync

Por lo general en la documentación te recomiendan que leas las noticias de Portage, en mi caso no tuve ningún problema, pero si lees este post y ha pasado un tiempo, es preferible que te informes:

# eselect news list
News items:
  [1]      2016-06-19  L10N USE_EXPAND variable replacing LINGUAS
  [2]      2018-08-07  Migration required for OpenSSH with LDAP
  [3]      2019-05-23  Change of ACCEPT_LICENSE default
  [4]   N  2019-12-30  Genkernel 4 changed default filenames
  [5]   N  2020-02-07  Python 2.7 went EOL
  [6]   N  2020-02-20  OpenSSH 8.2_p1 running sshd breakage
  [7]      2020-04-22  Python 3.7 to become the default target

Para leer una a una:

# eselect news read 1
2016-06-23-l10n-use_expand
  Title                     L10N USE_EXPAND variable replacing LINGUAS
  Author                    Mart Raudsepp <leio@gentoo.org>
  Author                    Ulrich Müller <ulm@gentoo.org>
  Posted                    2016-06-19
  Revision                  1

The L10N variable is replacing LINGUAS as a USE_EXPAND, to avoid a
conceptual clash with the standard gettext LINGUAS behaviour.
[...]

Seleccionando el perfil

Comprobamos que el perfil que tenemos es el correcto:

# eselec profile list
Available profile symlink targets:
  [1]   default/linux/amd64/17.0 (stable)
  [2]   default/linux/amd64/17.0/selinux (stable)
  [3]   default/linux/amd64/17.0/hardened (stable)
[...]

NOTA: Los perfiles tienen una serie de configuraciones de USE, CFLAGS, paquetes que no deben compilarse para evitar incompatibilidades...etc que están definidas por el equipo de desarrolladores de Gentoo. Puedes ver que USE contiene este perfilemerge --info | grep ^USE

NOTA: Las USE flags, son características que queremos que tenga el paquete, puede que existan incompatibilidades entre paquetes al definirlas, otras no estén disponibles, y otras pueden estar bloqueadas por motivos de estabilidad package.mask.

En esta lista, debe estar marcado con asterisco esta opción:

  [19]  default/linux/amd64/17.1/hardened/selinux (stable) *

Configurando los locales

Los "locales" es el soporte idiomático/codificación que queremos que tenga soportada por defecto nuestro sistema. En mi caso, he configurado que el idioma por defecto sea el inglés norteamericano y el español como idioma secundario. Ambos idiomas tienen soporte UTF-8.

# echo "en_US.UTF-8 UTF-8" >> /etc/locale.gen
# echo "es_ES.UTF-8 UTF-8" >> /etc/locale.gen

Generamos los locales:

# locale-gen

Seleccionamos el locale por defecto:

# eselect locale list
Available targets for the LANG variable:
  [1]   C *
  [2]   C.utf8
  [3]   en_US.utf8
  [4]   es_ES.utf8
  [5]   POSIX
  [ ]   (free form)

Lo cambiamos:

# eselect profile set 3

Regeneramos toda la configuración de nuestro entorno:

# env-update && source /etc/profile && export PS1="(chroot) ${PS1}"

Haciendo un pequeño tunning al /etc/portage/make.conf

Los siguientes pasos nos ayudarán en la instalación de los paquetes.

Soporte de instrucciones de procesamiento en paquetes

Instalamos el paquete app-portage/cpuid2cpuflags:

# emerge -av app-portage/cpuid2cpuflags

Ejecutamos:

# cpuid2cpuflags >> /etc/portage/make.conf

Editamos el archivo /etc/portage/make.conf y cambiamos:

CPU_FLAGS_X86: aes avx avx2 f16c fma3 mmx mmxext pclmul popcnt sse sse2 sse3 sse4_1 sse4_2 ssse3

Por esto:

CPU_FLAGS_X86="aes avx avx2 f16c fma3 mmx mmxext pclmul popcnt sse sse2 sse3 sse4_1 sse4_2 ssse3"

Esto nos añadirá el soporte específico para los paquetes que definen las instrucciones que tiene nuestro procesador para aquellos paquetes que lo permitan mediante USE. Puedes ver los paquetes que usan estas USE si lo buscas en una sección de la página de paquetes de Gentoo.

Soporte idiomático en las aplicaciones

También añadiremos la variable L10N="es en" para tener soporte idiomático de los paquetes que instalemos en nuestro sistema. 

# echo 'L10N="es en"' >> /etc/portage/make.conf

Definir la versión de Python por defecto para el sistema

Podemos optar por: * Python 2.7: Intentar evitarlo porque su soporte finalizó el 31 de diciembre de 2019, aún así pueden haber programas que lo necesiten. No obstante, si no lo defines no importa. * Python 3.6 * Python 3.7 * Python 3.8 * Python 3.9

En mi caso, escogí el 3.7 porque vi que no tenía problemas con él, en contra posición con el 3.8 o 3.9 que hay paquetes que no están todavía migrados como sys-apps/policycoreutils, también puedes mezclarlos, pero a mí no me gusta mucho esa idea.

# echo 'PYTHON_TARGETS="python3_7"' >> /etc/portage/make.conf

Dejando la versión por defecto 3.7 en el sistema:

# eselect python list
Available Python interpreters, in order of preference:
  [1]   python3.7
  [2]   python3.6 (uninstalled)
  [3]   python3.8 (fallback)
  [4]   python2.7 (fallback)

En mi caso, pues dejo por defecto 3.7

# eselect set 1

Instalando y configurando ccache

ccache permite ahorrarte tiempo en la compilación porque queda almacenado código compilado en un directorio definido en su configuración, siguiendo las notas de la documentación.

# emerge -av dev-util/ccache

Ejecutamos los siguientes comandos:

# echo 'FEATURES="ccache"' >> /etc/portage/make.conf
# echo 'CCACHE_DIR="/var/cache/ccache"' >> /etc/portage/make.conf

Creamos un directorio específico y aplicamos permisos:

# mkdir -p /var/cache/ccache
# chown root:portage /var/cache/ccache
# chmod 2775 /var/cache/ccache

Editamos el archivo de configuración /var/cache/ccache/ccache.conf y lo dejamos como este:

# Maximum cache size to maintain
max_size = 100.0G

# Allow others to run 'ebuild' and share the cache.
umask = 002

# Preserve cache across GCC rebuilds and
# introspect GCC changes through GCC wrapper.
compiler_check = %compiler% -v

# I expect 1.5M files. 300 files per directory.
cache_dir_levels = 3

compression = true
compression_level = 1

Regeneramos toda la configuración de nuestro entorno:

# env-update && source /etc/profile && export PS1="(chroot) ${PS1}"

Instalando el núcleo del sistema y algunas utilidades

Ejecutamos los siguientes comandos:

# echo ">=sys-kernel/linux-firmware-20200519 initramfs" >> /etc/portage/package.use/usevars
# echo ">=sys-firmware/intel-microcode-20200520_p20200601 initramfs" >> /etc/portage/package.use/usevars
# echo ">=sys-kernel/linux-firmware-20200519 linux-fw-redistributable no-source-code" >> /etc/portage/package.license
# echo ">=sys-firmware/intel-microcode-20200520_p20200601 intel-ucode" >> /etc/portage/package.license

Añadimos las USE para todo /etc/portage/make.conf:

USE="device-mapper lvm audit"

Instalamos los siguientes paquetes ys-kernel/gentoo-sources sys-apps/pciutils sys-kernel/genkernel sys-kernel/linux-firmware:

# emerge -av sys-kernel/gentoo-sources sys-apps/pciutils sys-kernel/genkernel sys-kernel/linux-firmware

Editamos el /etc/fstab

/dev/nvme0n1p2      /boot       ext4        noauto,noatime  1 2
/dev/nvme0n1p3      /boot/efi   vfat        noauto,noatime  1 2
/dev/mapper/gentoo-root /       ext4        noatime 0 0
/dev/mapper/gentoo-swap  none       swap        sw      0 0

Compilamos el núcleo y lo instalamos:

# genkernel all --lvm --luks

NOTA: En mi caso, preferí compilar el kernel con opciones personalizadas, es un proceso más engorroso y necesitas tener un poco más de conocimiento. Más adelante haré un pequeño tutorial de tres cosas básicas para optimizarlo, pero de momento, instalamos todo.

NOTA: Este proceso dura bastante, tómate 7-8 cafés...

Cuando termine, podemos verificar que se han instalado correctamente:

# ls /boot/vmlinu* /boot/initramfs*
/boot/initramfs-5.4.38-gentoo-x86_64.img  /boot/vmlinuz-5.4.38-gentoo-x86_64

Configurando la red

Configuramos el nombre de nuestra máquina a nivel de red, editamos el archivo /etc/conf.d/hostname:

# Set to the hostname of this machine
hostname="shark"

shark es el nombre que le asigno a mi máquina.

Le asignamos un dominio local, editamos /etc/conf.d/net:

# Set the dns_domain_lo variable to the selected domain name
dns_domain_lo="lan"

Mi máquina será identificada en la red como shark.lan

Instalamos el paquete net-misc/netifrc:

# emerge --ask --noreplace net-misc/netifrc

Editamos el archivo /etc/hosts y definimos el nombre de nuestra máquina en él:

127.0.0.1     shark.lan shark localhost
::1                shark.lan shark localhost

Gestionando los usuarios del sistema

Ejecutamos:

# passwd

Creamos un usuario sin privilegios:

# useradd -m sincorchetes
# passwd sincorchetes
# gpasswd -a sincorchetes wheel

Cambiando el idioma del teclado

Editamos el archivo /etc/conf.d/keymaps:

# Use keymap to specify the default console keymap.  There is a complete tree
# of keymaps in /usr/share/keymaps to choose from.
keymap="es"

Cambiando la hora del equipo

Editamos el archivo /etc/conf.d/hwclock

# Set CLOCK to "UTC" if your Hardware Clock is set to UTC (also known as
# Greenwich Mean Time).  If that clock is set to the local time, then
# set CLOCK to "local".  Note that if you dual boot with Windows, then
# you should set it to "local".
clock="local"

Instalando herramientas del sistema

Instalamos el gestor de logs app-admin/syslog-ng y el un software de rotado de logs app-admin/logrotate

# emerge -av app-admin/syslog-ng app-admin/logrotate
# rc-update add syslog-ng default

Instalamos el gestor de tareas sys-process/cronie:

# emerge -av sys-process/cronie
# rc-update add cronie default

Instalamos los paquetes net-misc/dhcpcd, net-wireless/iw y net-wireless/wpa_supplicant

# emerge -av net-misc/dhcpcd net-wireless/wpa_supplicant net-wireless/iw

Dejando SELinux en modo permissive

Cómo tenemos que aprender a tratar y gestionar nuestras propias políticas, tenemos que dejarlo en modo permissive y no targeted. En modo permissive, el sistema envía alertas de políticas incorrectas como una posible vulneración de se seguridad por ejecutar determinado software.

Editamos el archivo /etc/config/selinux y cambiamos:

SELINUX=targeted

Por:

SELINUX=permissive

Configurando el gestor de arranque

Añadimos las USE necesarias para compilar el software:

# echo ">=sys-boot/grub-2.04-r1 device-mapper truetype mount" >> /etc/portage/package.use/usevars

Añadimos el soporte EFI para el GRUB

# echo 'GRUB_PLATFORMS="efi-64"' >> /etc/portage/make.conf

Instalamos el GRUB y además actualizamos todo el software que necesite tomar las nuevas variables USE configuradas:

# emerge --ask --update --newuse --verbose sys-boot/grub:2

Instalamos el gestor de arranque, en mi caso fue con un nvme0n1:

# grub-install --target=x86_64-efi --efi-directory=/boot/efi

Generamos la configuración del gestor de arranque, editamos /etc/default/grub

GRUB_DISTRIBUTOR="Gentoo"
GRUB_CMDLINE_LINUX="dolvm crypt_root=/dev/nvme0n1p4"

NOTA: En el caso de que tengas la partición de LVM en /dev/sda4, cambia /dev/nvme0n1p4 por esa.

Guarda el archivo y genera el fichero de configuración del grub:

# grub-mkconfig -o /boot/grub/grub.cfg

Saliendo del chroot:

# exit

En la terminal del pendrive live:

# cd /
# umount -l /mnt/gentoo/dev{/shm,/pts,}
# umount -R /mnt/gentoo
# reboot

Arrancando el sistema

Cuando arranquemos el sistema, podemos hacer login con nuestro usuario y escalar a root. Para poder conectarnos via Wi-Fi, podemos usar wpa_supplicant.

Conectándonos a una red Wi-Fi

Identificamos nuestra interfaz Wi-Fi

# ip addr

Por regla general, las tarjetas wireless son mapeadas por el sistema con el nombre de wlpNsM, en mi caso es wlp0s4.

Generamos el archivo de conexión:

# wpa_passphrase SSID contraseña > /root/config

Conectamos:

# wpa_supplicant -D nl80211 -i wlan0 -c /root/config &

Asignamos una IP dinámica:

# dhcpcd wlp4s0

Si hacemos un ip addr, veremos que ya tendremos conexión, si no, probamos:

# ping google.es

Ahora podemos continuar instalando paquetes, en los próximos tutoriales, veremos cómo instalar X.org con los drivers de NVIDIA y MATE Desktop, las políticas de SELinux...etc