Aleatoriedad en BASH.

 (P) Hugo Napoli, 2021 

Procedimiento para obtener un número aleatorio utilizando la función RANDOM% de BASH.
Explicación "paso a paso", utilizando la sintaxis necesaria para un programa para este lenguaje de programación.

Recuerda introducir la línea

#!/bin/bash

al inicio del script para que el mismo funcione. Si quieres, también puedes agregar (debajo del #!/bin/bash) el comando clear, para limpiar la pantalla y que tu programa luzca mejor.

# Preguntaremos al usuario cuáles serán los valores (mínimo y máximo) permitidos, y
# los guardaremos en las variables min y max, respectivamente.

read -p "Introduzca el valor mínimo: " min
read -p "Introduzca el valor máximo: " max

# Ahora, determinaremos cuántos números estarán involucrados en la generación
# del número aleatorio. Esto se logra restándole al máximo el mínimo. Si se busca
# hallar un número entre 50 y 100, estarán involucrados 50 números en el proceso
# 100 (valor máximo) - 50 (valor mínimo) = 50 números.

base=$(($max-$min))

# Sumaremos 1 al valor obtenido, para que el sistema de aleatoriedad interno de BASH
# no produzca valores a partir de 0, sino a partir de 1 (de este modo, en lugar de
# producirse valores entre 0 y 49, se producirán entre 1 y 50).

base=$((base+1))

# Generaremos un número aleatorio que tendrá como límite mayor el valor calculado
# hasta ahora. Si se buscaba un número entre el 50 y el 100, con este procedimiento,
# obtendremos, en realidad, un número del 1 al 50.

n_aleatorio=$(( RANDOM% $base ))

# Al valor aleatorio generado, debemos sumarle el mínimo, para ajustar los límites del
# número verdaderamente buscado. Recordemos que los límites, originalmente, eran
# 50 y 100, pero hubo que convertirlos en 1 (mínimo) y 50 (máximo) debido al
# funcionamiento interno de BASH para este tipo de procedimiento.

n_aleatorio=$((n_aleatorio+$min))

echo ""
echo "El número aleatorio resultante, es el siguiente:" $n_aleatorio
echo ""

Ver cámara web en ventana sin bordes (aplicable a Linux, a Windows y posiblemente también a MAC).

     (P) Hugo Napoli, 2020.-     

Es increíble lo difícil que resulta alcanzar un cometido tan sencillo, en apariencia.

Cuando me pongo a pensar en la cantidad de horas invertidas buscando programas que solucionaran este tema (y esto aplica también para Windows), no puedo creer (aún) el hecho de haber encontrado solo 1 programa para Windows y ninguno para Linux (que cumplieran estos criterios):

• que funcionaran bien desde un inicio,
• que no necesitaran configuraciones previas complicadas,
• que una vez ajustadas las opciones necesarias, quedaran aplicadas "para siempre",
• que fueran gratuitos,
• que permitieran seleccionar una cámara determinada.

Esto, aunque parezca demasiado pedir, no debería serlo, ya que un programa debe proporcionar un conjunto de herramientas mínimas que sean posibles de configurar respecto al cometido que aborda.

Veamos cómo resolver esta situación, sistema por sistema y paso por paso.

Sobre MAC:

una vez más, MAC es una isla. Quien allí se mete, no solamente está obligado sujeto a pagar altos costos de manera innecesaria y a quedar como rehenes en solitario, sino que tampoco se le permite al usuario "externo a MAC" saber si las soluciones que se aplican a Linux (hermano de MAC OS, aunque no lo parezca), pueden ser aplicables también para MAC.

De modo que: espero que te vaya bien con la solución que encontré para Linux, ya que tu máquina y la mía hablan un idioma en común.

Sobre Linux:

Una sola línea de comandos hace la magia:

mplayer tv:// -tv driver=v4l2:width=640:height=320:device=/dev/video2:fps=30:outfmt=yuy2 -noborder -geometry 0:0 -zoom -x 250 -y 150 -vf mirror -ontop

Explicaré, de todo este complejo ensamblado de órdenes y parámetros, lo que está a mi alcance.

Vamos a descomponer a esta línea de comandos en varias partes.

mplayer tv:// -tv : indica que será utilizado el reproductor mplayer para mostrar la cámara web en lugar de ser utilizado para mostrar una película. Mplayer debe estar instalado en el sistema, lógicamente, para que esta línea tenga sentido.

driver=v4l2 : especifica el uso del controlador v412 (Video for Linux versión 2) para dicha tarea.

width=640:height=320 y fps=30 : ancho, alto y frecuencia de la resolución deseada, en píxeles y hercios, respectivamente. Es conveniente consultar con el manual de referencia de la cámara web, para conocer los valores nativos soportados por esta.

device=/dev/video2 : normalmente, en Linux se utilizan /dev/video0, /dev/video1, y en definitiva, /dev/videoN para identificar las diferentes cámaras web (o modos de las mismas) que estén conectadas al ordenador. En este caso, la cámara integrada en la máquina portátil que estaba utilizando en ese momento, era /dev/video0, pero a mí me interesaba aplicar esta línea de comandos a otra cámara que también estaba ya conectada, cuyo identificador era /dev/video2.

-noborder : ¡la magia! Esta línea quita el tan odioso borde que enmarca la imagen proporcionada por nuestra cámara web cuando queremos emitir o grabar un video en vivo con ventana no maximizada ni puesta a pantalla completa.

-geometry 0:0

 : lugar de la pantalla en donde queremos posicionar nuestra ventana de video. El primer número, representa la posición x, y el segundo, la y.

NOTA: todos los ejemplos siguientes, están basados en una resolución de pantalla de 1360 por 768, y una resolución de cámara de 640 por 320.

Por ejemplo:

• si queremos que la imagen de la cámara aparezca en el ángulo superior izquierdo, debemos poner los valores 0:0, sin importar la resolución de la pantalla ni la de la cámara web.

• si queremos que aparezca en el ángulo superior derecho, trabajaremos solamente con el ancho (x) y haremos la siguiente operación.
  1360-640=720. Como la altura en este caso no importa, los valores para geometry, deberán ser 720:0

• si queremos que se vea en el ángulo inferior izquierdo, debemos trabajar solamente con el alto (y) y hacer la siguiente operación. 768-320=448.
  Como la anchura en este caso no importa, los valores para geometry, deberán ser 0:448

• si queremos posicionar la imagen en el ánguo inferior derecho, deberemos trabajar con el alto y el ancho, y hacer las siguientes operaciones.
  Para el ancho: 1360-640=720. Para el alto: 768-320=448.
  Entonces, los valores para geometry, deberán ser 720:448

• Algo más complicado, pero no menos importante: podemos querer que la cámara esté situada justo en el centro. En ese caso, utilizaremos la vieja e infalible táctica de los taquígrafos.
  Ancho: (1360-640)/2=360. Alto: (768-320)/2=224.
  Entonces, los valores para geometry, deberán ser 360:224

-zoom -x 250 -y 150 : es el zoom, y aplica para achicar la imagen como para agrandarla.Independientemente de la resolución, podemos querer ajustar el tamaño de la ventana, como es mi caso. Esto posee relación directa con la resolución de la pantalla. Con valores 0:0, no hay zoom alguno, y el ancho y alto de la imagen de la cámara web, estará determinado por lo indicado en "geometry".

Con "-zoom -x 250 -y 150", le estamos indicando Mplayer que muestre a la imagen de la cámara web en un área de 250 píxeles de ancho por 150 de alto, con lo cual, podemos deducir que si cambiamos los valores a "-zoom -x 1360 -y 768", estaríamos ocupando toda la pantalla con la imagen de la cámara.

Es interesante probar con valores bajos, por ejemplo 40:25. Te llevarás una buena sorpresa.

-vf mirror : espeja horizontalmente la cámara. Yo prefiero utilizar este comando, pero no en todos los casos es necesario. Creo que en la mayoría de ellos, sí.

-ontop : ¿qué utilidad podría tener todo esto, si al querer "tocar" con el ratón cualquier cosa que no sea la ventana de la cámara, la misma se perdiera en el fondo, quedando tapada por una partida de videojuego, presentación con diapositivas, un video de fondo, el escritorio, ventanas abriéndose y cerrándose para mostrar procedimientos o una imagen? Para que la imagen de la cámara esté siempre "adelante del todo" (en primer plano) con total independencia de lo que haya detrás este parámetro es obligatorio.

Sobre Windows:

Amigos, les tengo que pedir algo de paciencia. Era urgente publicar esta información específicamente para Linux, pero decidí hacerla extensiva también para Windows. En breve (muy breve) estaré hablándoles del maravilloso software que encontré para realizar todo esto.

Cargar un script desde otro script en BASH

                               (P) Hugo Napoli, 2019                              

Imagen: https://github.com/odb/official-bash-logo

¿Es posible cargar un script desde otro script, en el lenguaje de programación BASH?

Pensando en el resto de los lenguajes para hacer programas, esto no solamente es posible, sino que es una técnica muy comúnmente utilizada.

BASH, presenta varios caminos (o técnicas) para dicho cometido, siendo de las más usuales, las que siguen.

I) bash "$0"

Acción: carga el mismo archivo que ya está siendo ejecutado.

Se utiliza -por ejemplo- cuando un script llegó a su fin, y se quiere preguntar si se desea comenzar otra vez. Obsérvese que en el siguiente programa, la instrucción ' bash "$0" ' es utilizada 2 veces, por 2 razones diferentes.

#!/bin/bash
clear
read -p "Ingresa el primer número a sumar: " num1
read -p "Ingresa el segundo número a sumar: " num2
resultado=$((num1+num2))
echo "El resultado es:" $resultado
echo ""
read  -p "¿Quieres hacer más sumas (sí/no)?" otra_vez
if [[ $otra_vez == "no" ]];then
     echo "Gracias por utilizar este programa. Ten un buen día :)"
     sleep 5
     exit
elif [[ $otra_vez == "sí" ]];then
     bash "$0"
else
     echo "No comprendí lo que escribiste. La próxima vez, escribe 'no' para terminar."
     sleep 5
     bash "$0"
fi 

Este es un método altamente efectivo y confiable.

II) bash "Otro script.sh"

Acción: carga el script llamado "Otro script.sh", el cual se encuentra en el mismo directorio que el programa que contiene esta instrucción.

Si el script que estamos creando está en la misma carpeta que los demás scripts que queremos cargar, solo basta con poner una línea de este tipo para lograr el objetivo.

Dependiendo de la terminal en donde estemos ejecutando los scripts y del sistema que esté siendo utilizado (variantes de Linux, MACOS, etc.), esto podría no funcionar, y devolver errores como "No se encontró el archivo", o "No existe el archivo 'Otro script.sh' ".

Puede funcionar en un ordenador, y en otro, no (aunque ambos sean capaces de interpretar código BASH).

III) bash "CAMINO Y NOMBRE DEL SCRIPT"

Este es un método parecido al anterior, salvo que si el script que queremos cargar no está en el mismo directorio que nuestro script, debemos indicárselo a BASH:

bash "/home/estudiante/Documentos/programas/menú.sh"

Esta línea, cargará el script llamado "menú.sh", el cual se encuentra dentro de la carpeta "programas", en el directorio "Documentos" del usuario "estudiante".

Este también es un método altamente efectivo y confiable, salvo para cuando se mueven archivos de su lugar original. En este caso, hay que cambiar obligatoriamente "/home/estudiante/Documentos/programas/" por lo que corresponda.

IV) Utilizando el comando "dirname"

"$0" es la forma de BASH de identificar inequívocamente al script en ejecución.

Si con "$0" ejecuta a dicho script sin margen de error, es lógico pensar en que podríamos utilizar "$0" en otro procedimiento... ¿no es así?

¿Qué tal si guardamos en una variable el "camino" de nuestro script, para poder reutilizarlo cada vez que sea necesario?

¡Hagámoslo y probemos!

camino=$(dirname "$0")

Ahora, solo basta con escribir siempre "$camino" y a continuación, adjuntar el nombre del archivo que queremos cargar, separando ambos elementos (la variable y el nombre del script) por una barra de dividir:

bash "$camino/Mi archivo.sh"

Este es otro método altamente efectivo y confiable más, que funciona aunque el script sea movido de su lugar o copiado en otro ordenador.

Servidor OpenSuSE en modo consola

                               (P) Hugo Napoli, 2019                              

Imagen: https://www.networkworld.com/article/3334781/suse-releases-enterprise-linux-for-all-major-arm-processors.html

Esta instalación fue concebida para una máquina portátil convencional, de prestaciones básicas.

También fue muy importante que el tiempo invertido en la concreción de este proyecto no fuera excesivamente "largo".
La idea, es presentar una guía rápida y útil, y a su vez, también rápidamente, poner un servidor Linux a funcionar, sin mucho trámite ni burocracia.

Para la preparación de un servidor de mayor "potencia", habría que hacerle un montón de ajustes a este artículo, o bien, escribir otro, únicamente para ello.

Hemos tenido en cuenta a aquellos procedimientos que representan un trabajo muy tedioso al ser realiozados desde la consola, y para alivianar la carga laboral, los realizaremos sirviéndonos del entorno gráfico que facilita OpenSuSE durante la fase de instalación.

Es importante aprovechar el entorno gráfico, sin desmerecer al resto de las herramientas disponibles. Luego, todo se reducirá a una pantalla negra y un teclado.

Dejaremos para después, entonces, únicamente aquello que sea más o menos sencillo de realizar en modo consola.

Parte I/III: preparación de OpenSuSE.

                  MODO "GRÁFICO"                 

Particionado.

Considerando que el servidor poseerá una partición especialmente dedicada a datos (fuera de "home"), reduciremos el tamaño de home a un mínimo aceptable, cuando en realidad debería ser mucho más grande en una instalación estandarizada.

Tamaños para las particiones:

boot:  512 MB,

root:  20 GB,

tmp:   10 GB,

swap:  4 GB (o igual de "grande" que la cantidad de memoria RAM instalada en el equipo),

home:  8 GB,

datos: todo el espacio restante libre.

La partición "datos", deberá ir montada en "/datos", con la opción "el usuario puede montar la partición".

Arranque.

Marcaremos la opción en Grub2 acerca de proteger con contraseña el cargador de arranque (es recomendable utilizar una contraseña diferente a la del usuario root, para aumentar la seguridad del sistema).

Si este paso no se realiza en este momento (durante la instalación), será bastante difícil llevarlo a cabo después, puesto que no habrá escritorio ni ventanas en donde hacer clic, buscar información, etc.

Desmarcaremos la opción de "buscar sistemas operativos foráneos", ya que OpenSuSE será el único en este ordenador.

Repositorios.

Repositorios no oficiales y no open source se han desestimado.
Por consiguiente, únicamente se han utilizado los dos oficiales y de código abierto (no packman, ni libdvdcss, ni ningún otro).

Puertos y servicios.

Puerto y servicio SSH: abiertos

Red.

Podemos configurar la IP estática del servidor durante esta fase, así también como el encaminamiento y los distintos atributos del nombre de "host", pero lo explicaremos breve y detalladamente más abajo, en "modo consola".

Software adicional.

Marcar para instalar mysql-workbench
Los servicios más utilizados, probablemente sean samba y este que acabamos de citar.

Finalizar la instalación.

                  MODO "CONSOLA"                 

          Iniciar sesión como usuario root antes de proseguir         

Más ajustes en el cargador de arranque.

Reducción del tiempo de espera para la carga del sistema.

El tiempo "por omisión" del cargador de arranque (Grub) en OpenSuSE es de 8 segundos.

Durante este tiempo (y si no se pulsa Enter) Grub espera a que el usuario pulse la tecla "e" para pasarle parámetros de inicio al sistema.

Esto puede ser útil una vez cada cierto tiempo, o bien puede no ser necesario en absoluto.

Lo cierto, es que no es útil para el día a día, por lo tanto, lo reduciremos a 1 segundo.

A partir de ahora, si alguien necesita pasarle parámetros a Grub, será mejor que se preocupe por estar muy atento a la pantalla de arranque.

Escribiremos, entonces:

nano /etc/default/grub (y daremos "Enter")

Cambiaremos GRUB_TIMEOUT=8 por GRUB_TIMEOUT=1

CTRL + O y ENTER para confirmar los cambios y guardar, y
CTRL + X para finalizar la edición del archivo de arranque.

No buscar sistemas operativos foráneos.

Cuando hay más de 1 sistema instalado en la misma máquina, es correcto mantener esta configuración tal como viene por omisión, pero, tratándose de la búsqueda de la reducción máxima de los tiempos de arranque del servidor, cambiaremos la línear GRUB_DISABLE_OS_PROBER="false" por GRUB_DISABLE_OS_PROBER="true"
Con esto, nos aseguraremos que OpenSuSE será el único sistema que Grub "verá"; por lo tanto, no "perderá tiempo" buscando a otros.

Adicional.

Se puede emitir un pitido al iniciarse Grub (muy recomendable para máquinas que no van a tener conectado un monitor para poder comprobar visualmente su estado), activando la línea GRUB_INIT_TUNE="480 440 1".
Para ello, simplemente debemos quitarle (a dicha línea) el símbolo # (y posiblemente el espacio) que la misma posee al inicio.

Al finalizar con estos cambios, debemos escribir en la consola lo siguiente:

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

Pulsaremos "Enter", entonces, para terminar de reconfigurar Grub.

Creación de usuarios del sistema.

Se puede crear un usuario, darle nombre, directorios personales y descripción, todo en una sola línea.
El comando necesario para ello, es "useradd". Los parámetros "-m" y "-d", hacen que el usuario sea creado con directorio home incluido (y, por consecuencia, con sus directorios personales "Descargas", "Documentos", Escritorio", "Imágenes", etc.). A la misma línea, puede agregársele un comentario (atributo --comment), el cual será el "nombre fantasía" del usuario en cuestión.
Así se escribe:

useradd -m -d /home/estudiante estudiante --comment "Estudiante Liceo IEP"

Inmediatamente, habrá que establecer una contraseña para el inicio de sesión en OpenSuSE, y para ello, ejecutaremos lo siguiente:

passwd estudiante

Crearemos, de este modo, todos los usuarios de sistema que sean necesarios.

Al finalizar, será necesario registrar la contraseña de cada usuario del sistema en Samba, para permitir a los usuarios del sistema conectarse con equipos de la intranet (o red a la cual ya estén conectados), o a equipos "remotos" (hacia y desde Internet).

Para esto, escribiremos lo siguiente y pulsaremos "Enter":

smbpasswd -a estudiante

Y así haremos con todos los usuarios del sistema (OpenSuSE) que queramos que posean las capacidades que acabamos de comentar, es decir, que puedan conectarse desde y hacia otras máquinas (Samba), ya sean estas "cercanas" o "remotas".

Dar nombre al equipo.

En Linux, el "nombre de host" o "nombre de equipo", puede poseer más de una denominación.
Lo que generalmente se considera, es el "host name" (o "static name"), pero existen también el "pretty name", el "icon name" (o "transient name") y otros.

El "host name", es el clásico "nombre de red" del equipo: es el nombre por el cual la máquina será identificada en la red.

hostnamectl set-hostname "servidor-linux" --static

El "pretty name" es mas bien la descripción del equipo, es decir, una idea del uso que se le da a ese ordenador (o del tipo de trabajo que en él se desempeña), expresada en pocas palabras.

hostnamectl set-hostname "Máquina del proyecto ITEX" --pretty

El "icon name" es el nombre de... no sé, pero existe XD
Generalmente, se utiliza para indicar el tipo de computadora, por ejemplo: servidor de datos, servidor http, servidor dhcp, máquina de escritorio, etc.
También, generalmente, no se dejan espacios al crear este nombre. Los mismos se sustituyen por guiones (signos de "menos").

hostnamectl set-icon-name "servidor-local-de-datos"

Para ver los cambios (o para consultar todos los nombres de un equipo), podemos ejecutar el comando:

hostnamectl

Conectar a través de la terminal a redes inalámbricas.

A través del servicio wicked (el que ya se está ejecutando en OpenSuSE):

* * * PROCESO PENDIENTE * * *

A través de Gnome Network Manager:

nmcli d wifi connect <SSID> password <CONTRASEÑA> iface <INTERFAZ_DE_RED>

Dar IP estática al equipo.

Para ver las conexiones físicas de red (es decir: ver con qué nombres lógicos OpenSuSE identifica a las conexiones físicas), ejecutaremos:

ip link show (o ip link)

Con esto, obtendremos algo parecido a lo que aparece aquí:

lo = loopback.

El dispositivo de red loopback es una interfaz de red virtual. La (...) dirección (...) [que] se utiliza, de forma mayoritaria, [es] la '127.0.0.1' (...), [añadiéndose] '::1' para el caso de IPv6 ('127.0.0.1::1').

Las direcciones de loopback pueden ser redefinidas (...), y son usualmente utilizadas para probar la capacidad de la tarjeta interna [y ver] si se están enviando datos BGP [Border Gateway Protocol]. 

[BGP] es un protocolo mediante el cual se intercambia información de encaminamiento entre sistemas autónomos. (...) Los proveedores de servicio registrados en Internet [,] suelen componerse de varios sistemas (...) [de este tipo].

Texto tomado de Wikipedia, con modificaciones del autor del post.

eth0 = ethernet 0

Conexión física tipo "RJ45" (cableada común).

wlan0 = wireless lan 0

Conexión física tipo "wifi" (inalámbrica común).

Una vez que sepamos a qué dispositivo (lo, eth0, wlan0, etc.) queremos asignarle una dirección IP fija, ejecutaremos:

ip addr add xxx.xxx.xxx.xxx/yy dev zzz

Siendo:

xxx.xxx.xxx.xxx = bits de la dirección de red, tales como 192.168.6.100

yy equivale a la máscara de red, y normalmente es "/24" (por "8 x 3 = 24"), lo cual equivale a los 3 primeros bit "encendidos" (en 255) y el último "apagado" (en 0): 255.255.255.0.

zzz es uno de los nombres que aparece cuando ejecutamos ip link show, y responde al dispositivo físico con el cual queremos trabajar.

Ejemplo general:

ip addr add 192.168.6.100/24 dev eth0

Luego de esto, habrá que apagar y encender la conexión de red, a los efectos de actualizarla:

ip link set eth0 down
ip link set eth0 up

Para visualizar esta información y comprobar que todo está bien, podemos ejecutar:


ip addr show zzz

Ejemplo:

ip addr show eth0

También es útil el comando ip route para esto mismo.

Habilitar e iniciar demonios Samba y NetBios.

Generalmente, los protocolos "Server Message Block" (smb) y "NetBios Message Block" (nmb), no están habilitados al inicio del sistema (y por consiguiente, tampoco están encendidos).

Lo que debemos hacer, es correr los siguientes comandos, para habilitarlos:

systemctl enable smb
systemctl enable nmb

Ahora que están habilitados, hay que encenderlos:

systemctl start smb
systemctl start nmb

Para comprobar el estado de actividad de ambos protocolos:

service smb status
service nmb status

Imagen de salida de consola de los comandos "service smb status" y "service nmb status", en un equipo al cual no se le habían habilitado ni activado los protocolos smb y nmb previamente:

Imagen de salida de consola de los comandos "service smb status" y "service nmb status", en un equipo al cual se le acaban de habilitar (pero no de activar) los protocolos smb y nmb:

Imagen de salida de consola de los comandos "service smb status" y "service nmb status", en un equipo al cual se le acaban de habilitar y activar los protocolos smb y nmb. Ahora sí, el sistema está listo para comenzar a actuar como servidor de datos:

Parte II/III: preparación de Samba y NFS.

Creación y preparación de directorios.

Anteriormente, habíamos creado un directorio en el directorio raíz del sistema:

/datos

Algo bien importante es tener en claro que los permisos de acceso debería otorgarlos samba, según la información dentro de "smb.conf", no el sistema (OpenSuSE).

Imaginemos los casos siguientes:

Linux permite acceder a /datos, pero Samba no. Resultado: fracaso.
Linux no permite acceder a /datos, pero Samba sí. Resultado: fracaso.
Linux permite acceder a /datos, y Samba también. Resultado: éxito.

Evidentemente, quien obligatoriamente debe permitir el acceso es Samba, ya que los equipos que se conectarán al servidor, lo harán a traves de su protocolo.

Se pueden establecer credenciales de acceso a través de permisos de Linux y Samba, conjuntamente, pero eso implicaría un trabajo más pormenorizado que tendría que ver con la asignación de permisos diversos (lectura, ejecución, escritura) por usuario y por grupo en Linux, que no veremos en este artículo.

Por consiguiente, dejaremos "via libre" (en Linux) al directorio "/datos", y controlaremos su acceso únicamente a través de Samba, solo por temas de practicidad.

Como solamente el usuario "root" puede escribir en el mencionado directorio, haremos:

chmod 777 /datos

chmod = change mode.

Luego de esto, crearemos los directorios "00_info" y "datos_de_usuario", dentro de /datos:

cd /datos
md 00_info
md datos_de_usuario

cd = change directory.

md = make directory.

De nuevo, daremos via libre (en Linux) a los directorios recientemente creados, para que Samba controle totalmente el acceso al mismo:

chmod 777 00_info
chmod 777 datos_de_usuario

Respaldo y modificación del archivo Samba.

Conviene -siempre antes de manipular un archivo esencial para el sistema- realizar una copia del mismo (con otro nombre, lógicamente).
Haremos una copia, entonces, de "smb.conf", y la llamaremos "smbANT.conf":

cd /etc/samba
cp smb.conf smb_ANT.conf

cp = copy

Ahora que estamos trabajando sobre seguro, utilizaremos el editor "nano" para editar el archivo Samba:

nano smb.conf

Traduciremos los encabezados al español.

Cambiaremos [homes] por [directorios_home].

Cambiaremos [profiles] por [perfiles], y así con todos los encabezados.
Luego, continuamos con la primera línea de cada encabezado:

workgroup = WORKGROUP, por workgroup = aula (puede ser cualquier palabra, no precisamente debe ser "aula").
comment = Home Directories, por comment = Directorios 'home'.
comment = All users, por comment = Usuarios, y así con todas las líneas "comment" que haya.


Al final de todo, agregaremos:

[00_info]
          comment = Reglamentación e información del uso del servidor.
          path = /datos/00_info
          readonly = yes
          valid users = root,estudiante,sololectura

[datos_de_usuario]
          comment = Directorio de datos del servidor OpenSuSE Linux.
          path = /datos/datos_de_usuario
          readonly =no
          valid users = root,estudiante,sololectura

CTRL + O     ENTER
CTRL + X

Ahora es momento de ejecutar systemctl restart nmb (reinicio de NetBios), puesto que hemos alterado información en el encabezado [global] y hay que informárselo a toda la intranet (o a la red).

debido a que todos los demás encabezados también han sido editados, también debemos ejecutar systemctl restart smb para el reinicio de Samba. 

Ahora, pondremos un archivo de texto dentro del directorio 00_info (opcional).

cd /datos/00_info

Con "echo" escribiremos cada línea, y con ">>" nos aseguraremos de que lo que previamente existía en el archivo, no sea borrado por lo que estemos escribiendo a continuación.

Ejemplos.

I

echo "Hola." > info.txt
echo "¿Qué tal?" > info.txt

Resultado:

El archivo "info.txt" posee el contenido "¿Qué tal?", el cual sobreescribió (y por lo tanto, borró) al contenido "Hola." que existía previamente. ">", implica "sustituír".

II

echo "Hola." >> info.txt
echo "¿Qué tal?" >> info.txt

Resultado:

El archivo "info.txt" posee el contenido

Hola.
¿Qué tal?

Esto es así, porque el indicador ">>" implica "agregar".

Para crear un archivo con varias líneas de texto dentro, escribiremos cada una de las líneas siguientes, pulsando ENTER al final de cada una de ellas.


echo "Reglamentación e información importante." >> info.txt
echo "---------------------------------------- >>" info.txt
echo "Al utilizar este servidor de datos, ud se compromete a no alojar archivos" >> info.txt
echo "que no sean de trabajo, tales como películas, álbumes musicales, respaldos" >> info.txt
echo "personales, etc." >> info.txt
echo "Ud. también entiende que este es un servicio que no posee garantía, ya que" >> info.txt
echo "se brinda únicamente para la seguridad y flexibilidad del usuario." >> info.txt
echo "La no lectura de este documento, no es causa para que se efectúen reclamos" >> info.txt
echo "por falta del servicio, pérdida o alteración de datos, etc." >> info.txt
echo "Por otra parte, le aseguramos que mantendremos en condiciones el servidor." >> info.txt
echo "Al mismo, se le realizarán tareas de mantenimiento y respaldo de la información," >> info.txt
echo "de ser posible. Se lo protegerá de ataques externos, pero no del mal uso" >> info.txt
echo "de los usuarios habilitados." >> info.txt
echo "Disfrute a Linux. Sea bienvenido, and have a lot of fun!" >> info.txt

Parte III/III: configuración del cortafuegos.

Cortafuegos o firewall.

Habilitar e inhabilitar el cortafuegos.

systemctl enable firewalld
systemctl disable firewalld

Iniciar y detener el cortafuegos.

systemctl start firewalld
systemctl stop firewalld

Algunos comandos más a tener en cuenta.

init 6: reiniciar equipo
init 0: apagar el equipo

Este artículo está dedicado al grupo de 3er. año de Informática (egreso 2019) de Liceo IEP.

1era. actualización: 22/10/2019.

2a. actualización: 24/10/2019.
3a. actualización: 28/10/2019.

Fuentes consultadas:

Centro Linux

https://cubiclenate.com/linux/system-configuration/simple-samba-setup/

https://www.freedesktop.org/software/systemd/man/hostnamectl.html

https://doc.opensuse.org/documentation/leap/reference/html/book.opensuse.reference/cha.grub2.html

https://unix.stackexchange.com/questions/422104/make-grub-boot-on-default-without-waiting

https://web.mit.edu/rhel-doc/4/RH-DOCS/rhel-rg-es-4/s1-samba-daemons.html

https://www.linuxbabe.com/command-line/ubuntu-server-16-04-wifi-wpa-supplicant

https://www.initpals.com/suse/how-to-enable-or-disable-firewall-in-sles-15/

https://upcloud.com/community/tutorials/troubleshoot-network-connectivity-linux-server/

https://www.tecmint.com/linux-networking-commands/

https://web.mit.edu/rhel-doc/4/RH-DOCS/rhel-rg-es-4/s1-samba-servers.html

https://www.sergio-gonzalez.com/doc/10-ldap-samba-cups-pykota/html/samba-configuracion-estructura-smb.conf.html

https://es.wikipedia.org/wiki/Loopback

https://es.wikipedia.org/wiki/Border_Gateway_Protocol

https://www.howtogeek.com/177621/the-beginners-guide-to-iptables-the-linux-firewall/

Actualizar Opensuse a una nueva versión (upgrade)

                               (P) Hugo Napoli, 2019                              

Actualizar un sistema operativo desde la versión actual a una superior, puede ser un trabajo muy sencillo desde la terminal, comprendiendo lo necesario.

Lo que debemos saber, antes que nada, es que no se deben "saltar" o saltear versiones intermedias, si existiesen.

Esto significa que, para actualizar Opensuse desde la versión 13.1 a la 15.1 (por ejemplo), habrá que respetar la siguiente secuencia:

Actualizar la versión 13.1 a la 13.2

Actualizar la versión 13.2 a la 42.1

Actualizar la versión 42.1 a la 42.2

Actualizar la versión 42.2 a la 42.3

Actualizar la versión 42.3 a la 15.0

Actualizar la versión 15.0 a la 15.1

En este caso, asumiremos que poseemos la versión 15.0, y necesitamos actualizar a la 15.1.

Otra cosa importante, es actualizar la versión disponible antes de realizar el upgrade.

Para esto, en la terminal, ejecutaremos los comandos para tal fin:

sudo zypper refresh

(para recargar el contenido de los repositorios existentes), y

sudo zypper update

para actualizar todos los paquetes a su última versión disponible.

NOTA: hubo algunos cambios desde que OpenSuse 15.1 fue producido y puesto en marcha.

Si estás actualizando desde la versión 15.1 a la 15.2, te recomiendo que leas todo este artículo, pero que no realices los pasos que en él se indican. Al final del mismo, hay una explicación para actualizar a la versión 15.2 que es muy sencilla de aplicar si se ha leído toda la información de esta entrada.

Luego, ejecutaremos:

sudo sed -i 's/15.0/15.1/' /etc/zypp/repos.d/*

Observemos los colores, para establecer analogías:

El comando "sed", localiza todos los archivos dentro del directorio /etc/zypp/repos.d, y remplaza el contenido "15.0", por "15.1".

Lo que sucederá, será que Opensuse ya no buscará paquetes de software en los repositorios de la versión "15.0", sino en la versión siguiente, es decir, la "15.1", y esto aplica para todos los repositorios existentes. Todos ellos serán alterados (ver el asterisco amarillo y su explicación, más arriba).

Luego, debemos recargar la información de los nuevos repositorios, para que el sistema "se entere" que ya hay paquetes disponibles, correspondientes a una nueva versión:

sudo zypper refresh

Y por último,

sudo zypper dup

porque "dup", significa "distro upgrade", es decir, actualizar todo el sistema (junto con todos los paquetes de software instalados en él) a la nueva versión siguiente.

Reiniciemos el sistema operativo para aplicar los cambios y disfrutar de una flamante versión de esta maravillosa distribución Linux.

Para quienes estén actualizando desde la versión 15.1 a la 15.2: buena suerte; ¡es más fácil hacer esto, que actualizar cualquier versión previa a la 15.2!

Luego de haber leído el artículo, solo deberás realizar los siguientes pasos.

I. Ve al gestor de repositorios (llamado "Repositorios de software", "Yast Software Repositories" o algo similar) y elimina todos los repositorios presentes. Si posees el repositorio "Kernel", puedes dejarlo como único repositorio.

Esto se hace seleccionando cada repositorio y pulsando el botón "Eliminar".

II. Ahora, agrega únicamente estos 2 repositorios: "distribution" y "update":

https://download.opensuse.org/distribution/leap/15.1/repo/oss/

http://download.opensuse.org/update/leap/15.1/oss

Obviamente, al realizar el paso anterior podrías haberlos dejado intactos en lugar de borrarlos, pero eliminar todo y luego agregar solo lo que sirve, creo que es una base más "limpia" sobre la cual comenzar a realizar esta compleja tarea de actualización a una versión superior.

III. Edita las URLs de los 2 repositorios que acabas de agregar, para que en lugar de "15.1" o "$releasever", aparezca "15.2".

Ejemplos.

Situación anterior:

https://download.opensuse.org/distribution/leap/$releasever/repo/oss/

http://download.opensuse.org/update/leap/$releasever/oss

Situación final:

https://download.opensuse.org/distribution/leap/15.2/repo/oss/

http://download.opensuse.org/update/leap/15.2/oss

IV. Por último, solo basta con ejecutar en la terminal

sudo zypper refresh

y luego

sudo zypper dup

Luego de esto, puedes agregar más repositorios de la comunidad, tales como "packman" (http://ftp.gwdg.de/pub/linux/misc/packman/suse/openSUSE_Leap_15.2/), non oss, etc., y si quieres ayudar, también puedes agregar al repositorio de "Actualizaciones sin probar", para reportar problemas a la comunidad OpenSuse y de este modo dar una mano para que otros puedan resolver problemas en los paquetes de software que todos utilizamos día a día.

Última actualización: 30/5/2020.

Fuentes consultadas: diccionario de la RAE para "remplazar y reemplazar", y para "saltar" y "saltear", traductor en línea de Google para buscar traducciones del término "upgrade", y los siguientes artículos:

https://www.computerhope.com/unix/used.htm

https://zeldor.biz/2018/06/upgrade-opensuse-42-3-to-15-0/

https://likegeeks.com/es/sed-de-linux/

Creación de un pen drive con Linux

                                                         (P) Hugo Napoli, 2018                                                        

Conceptos preliminares.

Lo primero que debemos tener en cuenta, es que necesitaremos un sistema operativo funcionando correctamente para realizar esta tarea. El sistema será lo que nos permitirá "meter a Linux en un pen drive".

Esta característica se conoce como "modo live" o "Linux Live", lo cual significa poder tener un sistema operativo en cualquier medio de almacenamiento (pen drive, discos duro externo, tarjeta de memoria, CD, DVD, etc.) que funcione sin ser instalado en una máquina (el "disco duro", en este caso, sería el "pen drive").

Si queremos trabajar con un sistema operativo diferente a Mageia, podemos utilizar un programa para esto, llamado UNetbootin, presente en la mayoría de los repositorios de las distribuciones Linux más reconocidas, y también disponible para Windows y MAC.

Mageia no es compatible con esta herramienta, y con casi ninguna incluida dentro de las distribuciones Linux más reconocidas, pero de todos modos, Mageia lo hace fácil: con un simple (pero poderosísimo) comando introducido en la terminal, se logra la magia :)

Será necesario un pen drive de, al menos, 8 GB. Uno de 4 GB podría funcionar, pero, por experiencia, esto se desaconseja.

Se explicará cómo se hace esto desde Linux primero, y de Windows nos ocuparemos al final del artículo (el programa utilizado será el mismo en ambos casos). De todos modos, los usuarios de sistemas Windows y MAC, deben leer el procedimiento llevado a cabo en Linux para comprender la idea.

El sistema operativo elegido para ser puesto en el pen drive, fue Mageia Linux, debido a varias razones prácticas, pero también se puede utilizar este instructivo para muchas distribuciones más: OpenSuse, Puppy Linux, Debian, Linux Mint, Centos, Fedora, Ubuntu, Gentoo, etc.

Estamos intentando tener en cuenta que la persona que esté leyendo este artículo, puede haber optado por una distribución Linux diferente a Mageia. No obstante, se recomienda utilizar alguna de las ya mencionadas, con fuerte énfasis en: OpenSuse para ser instalado en máquinas modernas, y Mageia para crear pen drives con Linux en modo "live". Mageia puede ser utilizado desde el pen drive y también desde allí mismo puede ser instalado en cualquier ordenador, pero no es tan robusto como OpenSuse. OpenSuse, por otra parte, es uno de los sistemas más robustos que existen en el mundo Linux, pero, de manera oficial, no permite el "modo live", más allá de que la comunidad de usuarios ya ha llevado esto a cabo.

Para instalar OpenSuse en un pen drive, se recomienda "Suse Studio ImageWriter", disponible para OpenSuse y para Windows:

¡Manos a la obra!

1. Si vamos a utilizar una distribución que no sea Mageia, debemos verificar que el programa UNetbootin esté instalado en nuestro equipo. De no ser así, iremos al centro de software de nuestra distribución y lo instalaremos. Recordemos que para OpenSuse se recomienda "Suse Studio ImageWriter", aunque UNetbootin puede ser utilizado también, si es que en nuestro sistema operativo, por alguna razón, no podemos instalar Suse Studio ImageWriter.

2. Hay que descargar Mageia, visitando su web oficial (clic aquí para ello), y siguiendo los siguientes criterios.

I) Haremos clic en el recuadro blanco que dice "mage!a" :)

II) Clic en "Medio Live" para optar por Mageia "en vivo", el cual se puede utilizar desde un pen drive.

III) Aunque es muy recomendable el uso del escritorio KDE, en este caso, seleccionaremos el escritorio XFCE, debido a que es más liviano y funcional en cuanto a la ejecución de cualquier distribución Linux desde un medio externo, tal como un pen drive.

IV) Elegiremos la arquitectura "amd64" -es decir, "64 bits"-, ya que la misma podrá hacer mejor uso del hardware. Prácticamente ya casi no existen computadoras de la tecnología "ix86" (32 bits) en el mercado.

V) Por último, solo quedará elegir entre "Enlace Directo" (descarga común que no se puede pausar ni interrumpir hasta su finalización) o "BitTorrent" (descarga mediante programas de gestión de torrents como qBitTorrent que puede ser retomada cuantas veces se necesite).
Para una sala de informática o centro en donde existan muchos ordenadores que vayan a ser utilizados para este procedimiento a la misma vez, se recomienda la opción BitTorrent, ya que el ancho de banda utilizado por muchas máquinas bajo la opción "Enlace Directo", haría casi infinito el tiempo de espera, y generaría potenciales problemas (descargas que no se pueden finalizar, descargas completas pero con archivos corruptos, caída de toda la conexión a Internet del lugar, etc.).
En una casa de familia o para descargasque no sean multitudinarias, se recomienda la opción "Enlace Directo", por su velocidad y practicidad.

3. Ahora viene la parte en donde debemos prestar más atención, puesto que trabajaremos desde la terminal y el más mínimo error puede producir consecuencias lamentables.

El comando a introducir, con los parámetros necesarios, será el siguiente:

dd if=NOMBRE_DEL_ARCHIVO_MAGEIA_DESCARGADO.iso of=/dev/sdxx bs=1M

* * * ATENCIÓN: SE ESCRIBE TODO EN LA MISMA LÍNEA, RESPETANDO ESPACIOS * * *

A continuación, se explicará qué información colocar en las partes celeste y anaranjada de la línea de comandos que  se acaba de exponer.

Los sistemas operativos Linux, "ubican" al "pen drive" en algún lugar de su propio árbol de directorios.

Un árbol de directorios es una estructura interna de "carpetas" que posee el sistema operativo para guardar sus propios archivos de funcionamiento.

Al conectar un pen drive, teléfono inteligente (smartphone), cámara digital fotográfica, memoria externa, disco o unidad de almacenamiento extraíble, etc., Linux "monta" este dispositivo en "algún lugar" de ese árbol, el cual es desconocido para nosotros.
Tenemos que averiguar con exactitud esta información, puesto que debemos utilizar este importante dato en la consola para poder finalizar nuestro trabajo de "meter a un Linux dentro de un pen drive".

Desde un punto de vista lógico (no físico), nos preguntaremos: ¿dónde está, entonces, el pen drive? ¿Dónde lo ha colocado Linux?

Para averiguarlo, abriremos la terminal o consola, solicitando de antemano privilegios de superusuario (nos convertiremos en "usuario root”).

Ahora es que necesitamos averiguar en dónde se hallan el punto de montaje y la ubicación real del pen drive.
  a. Si conocemos el nombre lógico del pen drive (en este caso, el nombre de ejemplo es “mageia_amd64”, podremos ejecutar los comandos mount | grep mageia (utilizando una parte del nombre) o mount | grep mageia_amd64 (utilizando el nombre completo) y verificar entonces la información que nos dará la consola acerca del punto de montaje del pen drive en el sistema.
    b. Si no conocemos el nombre lógico del dispositivo, ejecutaremos sencillamente el comando "mount" (sin parámetros). La diferencia radicará en que, de este modo, tendremos que analizar entre cierta cantidad de información, la única útil para saber en dónde está montado nuestro pen drive.

Para el procedimiento “a”, la información proporcionada por la consola, será parecida a esta:

/dev/sdb1 on /run/media/estudiante/mageia_amd64 type vfat (rw,nosuid,nodev,relatime,uid=1000,gid=1000,fmask=0022,dmask=0077,codepage=437,iocharset=iso8859-1,shortname=mixed,showexec,utf8,flush,errors=remount-ro,uhelper=udisks2)

Si utilizamos el procedimiento “b”, la consola lucirá más o menos así:

proc on /proc type proc (rw,relatime)

sysfs on /sys type sysfs (rw,nosuid,nodev,noexec,relatime)

devtmpfs on /dev type devtmpfs (rw,nosuid,size=1474056k,nr_inodes=368514,mode=755)

devpts on /dev/pts type devpts (rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=000)

tmpfs on /dev/shm type tmpfs (rw,nosuid,nodev)

tmpfs on /run type tmpfs (rw,nosuid,nodev,mode=755)

/dev/sda5 on / type ext4 (rw,relatime,data=ordered)

securityfs on /sys/kernel/security type securityfs (rw,nosuid,nodev,noexec,relatime)

tmpfs on /sys/fs/cgroup type tmpfs (ro,nosuid,nodev,noexec,mode=755)

cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd)

pstore on /sys/fs/pstore type pstore (rw,nosuid,nodev,noexec,relatime)

cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)

cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpu,cpuacct)

cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)

cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)

cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)

cgroup on /sys/fs/cgroup/net_cls type cgroup (rw,nosuid,nodev,noexec,relatime,net_cls)

systemd-1 on /proc/sys/fs/binfmt_misc type autofs (rw,relatime,fd=22,pgrp=1,timeout=300,minproto=5,maxproto=5,direct)

hugetlbfs on /dev/hugepages type hugetlbfs (rw,relatime)

debugfs on /sys/kernel/debug type debugfs (rw,relatime,mode=755)

mqueue on /dev/mqueue type mqueue (rw,relatime)

sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw,relatime)

/dev/sda2 on /media/windows type fuseblk (rw,nosuid,nodev,relatime,user_id=0,group_id=0,default_permissions,allow_other,blksize=4096)

/dev/sda1 on /boot type ext4 (rw,relatime,data=ordered)

/dev/sda8 on /home type ext4 (rw,relatime,data=ordered)

/dev/sda6 on /tmp type ext4 (rw,relatime,data=ordered)

tmpfs on /run/user/1000 type tmpfs (rw,nosuid,nodev,relatime,size=296260k,mode=700,uid=1000,gid=1000)

sunrpc on /proc/fs/nfsd type nfsd (rw,relatime)

/dev/sdb1 on /run/media/estudiante/mageia_amd64 type vfat (rw,nosuid,nodev,relatime,uid=1000,gid=1000,fmask=0022,dmask=0077,codepage=437,iocharset=iso8859-1,shortname=mixed,showexec,utf8,flush,errors=remount-ro,uhelper=udisks2)

En ambos casos, se puede apreciar que el pen drive está montado en /run/media/estudiante (ver el texto resaltado en fucsia), y que su ubicación real es /dev/sdb1 (ver el texto resaltado en verde) lo cual era la información que necesitábamos averiguar .

Entonces, ahora sí estamos en condiciones de introducir el comando en la terminal, sin temor a fallar:

dd if=Mageia-6-LiveDVD-Xfce-x86_64-DVD.iso of=/dev/sdb1 bs=1M

* * * NUEVAMENTE: SE ESCRIBE TODO EN LA MISMA LÍNEA, RESPETANDO ESPACIOS * * *

MUY IMPORTANTE: No olvidemos introducir el comando "exit" en la consola, al finalizar todo este procedimiento, para dejar de ser usuario "root" y regresar a nuestro normal estado "user".

Entrada creada para los maravillosos 2os años de Liceo Areteia, pero igualmente útil para cualquier internauta :)

Artículos consultados:

https://informatica-hugonapoli.blogspot.com/2017/09/crea-tu-pen-drive-arrancable-desde.html

ARTÍCULO EN CONSTRUCCIÓN...