Ejercicios de shell scripting#

Crea un script llamado disk.sh que imprima por pantalla el porcentaje que esta ocupada la partición /home. Tiene que quedar:

75% /home

#!/bin/bash

df -h | grep home | tr -s ' '| cut -d' ' -f5-

Crea un script llamado mem.sh, obtiene solamente la memoria en MB ocupada y haz que se escriban en un archivo llamado free.log cada vez que se ejecute, sin borrar el anterior registro.

#!/bin/bash

free -h | grep Mem | tr -s ' ' | cut -d' ' -f4 >> free.log

Crea un script llamado mac.sh que obtiene la MAC de tu tarjeta de red

#!/bin/bash

ip link show enp2s0 | grep link | tr -s ' ' |  cut -d' ' -f3

Crea un script llamado listar_usuario_grupo.sh que saque por pantalla el nombre de los usuarios que hay creados en el sistema y al grupo que pertenecen, por ejemplo

alumno1 : smr1
alumno2 : smr1
alumno3 : asir1
alumno4 : asir2

#!/bin/bash
for i in $(cat /etc/passwd | grep bash | grep -v root | cut -d':' -f1)
do 
  groups $i
done

Crea un script llamado lastlog_ip.sh que muestre un listado ordenado con el nº de veces que se a logueado cada ip, por ejemplo

10.2.104.100
10.2.3.100
139.47.103.76
10.2.105.100
2.153.195.106
10.2.4.100
10.2.105.106

#!/bin/bash

for i in $(last -w | tr -s ' '  | cut -d' ' -f3 | sort |  grep '\.' | uniq); 
do 
  echo $(last -w| grep -c $i) $i 
done | sort -rn

#last -w | tr -s ' '  | cut -d' ' -f3 | grep '\.' | sort | uniq -c | sort -r

Crea un script llamado lastlog.sh que muestre un listado ordenado con el nº de veces que se a logueado cada usuario y el grupo al que pertenecen, por ejemplo

alumno1 smr1
alumno2 smr1
alumno3 asir1
alumno4 asir2

#!/bin/bash

for i in $(last -w | sort | cut -d' ' -f1 | uniq | egrep -v reboot | egrep -v  wtmp)
do 
  echo $(last -w| grep -c $i) $i  $(groups $i | cut -d':' -f2)
done | sort -rn

#last -w | tr -s ' '  | cut -d' ' -f1 | sort | uniq  -c | sort -r

Crea un script llamado tabla_multiplicar_read.sh que pide un número al usuario y muestre su tabla de multiplicar

#!/bin/bash

echo "Introduce un número para mostrar su tabla de multiplicar: "
read numero

for ((i=1;i<11;i++))
do
    resultado=$((numero * i))
    echo "$numero x $i = $resultado"
done

Crea un script llamado tabla_multiplicar.sh, ahora no preguntara por el numero al usuario y haz muestre su tabla de multiplicar cuando se ejecute por ejemplo ./tabla_multiplicat.sh <N> siendo <N> un numero del 1 al 10.

En el caso de ejecutar ./tabla_multiplicat.sh --help mostrara un mensaje de ayuda (consejo utiliza una función)
En el caso de ejecutar ./tabla_multiplicar.sh X Y Z ... , es decir con más de un argumento saldrá un mensaje No se puede dar más de un argumento
En el caso de ejecutar ./tabla_multiplicar.sh sin argumentos se ejecutara la opción de –help

#!/bin/bash

mostrar_ayuda() {

    echo "Uso: ./tabla_multiplicar.sh [número]
    Este script muestra la tabla de multiplicar del número que se le pase como argumento.
    Opciones:
      --help   Muestra este mensaje de ayuda.

    Ejemplos:
    ./tabla_multiplicar.sh 4   Muestra la tabla de multiplicar del 4."
}


if [[ $# -eq 0 ]]
then
    # Sin argumentos: mostrar ayuda
    mostrar_ayuda
elif [[ $1 == "--help" ]]
  then
    mostrar_ayuda
else
    numero=$1
    for ((i=1;i<11;i++))
    do
      resultado=$((numero * i))
      echo "$numero x $i = $resultado"
    done
fi

#!/bin/bash

mostrar_ayuda() {
    echo "Uso: ./tabla_multiplicar_array.sh [número]
    Este script muestra la tabla de multiplicar del número que se le pase como argumento.
    Opciones:
      --help   Muestra este mensaje de ayuda.

    Ejemplos:
    ./tabla_multiplicar.sh 4   Muestra la tabla de multiplicar del 4."
}


if [[ $# -eq 0 ]]
then
    # Sin argumentos: mostrar ayuda
    mostrar_ayuda
elif [[ $1 == "--help" ]]
  then
    mostrar_ayuda
else
    numero=$1
   for ((i=1;i<11;i++))
   do
     A[$i]=$i
   done
   longitud=${#A[@]}
   for((i=1;i<$longitud;i++))
   do
     echo "$numero x ${A[$i]} = $(($numero * ${A[$i]}))"
   done
fi

Crea una carpeta llamada imagenes, entra dentro y ejecuta los siguiente comandos:

for i in jpeg jpg png gif tiff bmp svg
do
  for((j=0;j<10;j++))
  do
    echo imag_${RANDOM}.$i > imag_${RANDOM}.$i
  done
done

Crea un script llamado imag.sh que cambie todas extensiones de todos los archivos a png conservando el nombre

#!/bin/bash

nlineas=$(wc -l temperatura.dat | cut -d' ' -f1)
T=0.00
for((i=1;i<=$nlineas;i++))
do 
  T=$(echo "scale=2; $T+$(head -$i temperatura.dat | tail -1)" | bc -l)
done
T_media=$(echo "scale=2; $T/$nlineas" | bc -l)
echo "Tenemos $nlineas temperaturas, de media T = $T_media"

Crea un script llamado temperatura.sh, que lea las temperatura del archivo temperatura.dat y saque por pantalla la temperatura media

#!/bin/bash

nlineas=$(wc -l temperatura.dat | cut -d' ' -f1)
T=0.00
for((i=1;i<=$nlineas;i++))
do 
  T=$(echo "scale=2; $T+$(head -$i temperatura.dat | tail -1)" | bc -l)
done
T_media=$(echo "scale=2; $T/$nlineas" | bc -l)
echo "Tenemos $nlineas temperaturas, de media T = $T_media"

#!/bin/bash

media=$(awk '{ suma += $1 } END { print suma/NR }' temperatura.dat )
ntemperaturas=$(awk 'END { print NR }' temperatura.dat)

echo "Tenemos $ntemperaturas temperaturas, de media T = $media"

#!/bin/bash

nlineas=$(wc -l temperatura.dat | cut -d' ' -f1)
for((i=1;i<=$nlineas;i++))
do
  T[$i]=$(head -$i temperatura.dat | tail -1) 
done

suma=0.00
for((i=1;i<=$nlineas;i++))
do
  suma=$(echo $suma+${T[$i]} | bc -l)
done
echo $suma 

T_media=$(echo "scale=2; $suma/$nlineas" | bc -l)
echo "Tenemos $nlineas temperaturas, de media T = $T_media"

Haz un script llamado rnd.sh que muestre 5 números aleatorios del 1 al 10 seguidos de el mismo número de As,

A
AAA
A
AAAAAA
AA

Haz que el reciba como argumento de entrada en numero de intentos, es decir ./rnd.sh 5

En el caso de no recibir ningún numero haz que saque 5

#!/bin/bash

n=${1:-5}

for (( i = 0 ; i < n ; i++ ))
  do
  x=$((RANDOM % 10 + 1))' '
  out=$x' '
  for (( j=0 ; j<x ; j++ ))
    do
      out=${out}A
    done
  echo $out
done

#!/bin/bash

n=${1:-5}

for (( i = 0 ; i < n ; i++ ))
  do
  x=$((RANDOM % 10 + 1))' '
  A[$i]=$x' '
  for (( j=0 ; j<x ; j++ ))
  do
    A[$i]=${A[$i]}A
  done
done


for (( i = 0 ; i < n ; i++ ))
do
  echo ${A[$i]}
done 

Haz un script llamado adivina.sh que escoja un numero aleatorio entre 1 y 20, pregunte al usuario, le diga si es más pequeño o más grande y que continué hasta que acierte.

Cuando el usuario acierte haz que muestre el número de intentos.

#!/bin/bash

# Generar un número aleatorio entre 1 y 20
numero_secreto=$((RANDOM % 20 + 1))
echo $numero_secreto
intentos=0

echo "¡Adivina el número entre 1 y 20!"

acertado=0
while [[ $acertado == 0 ]]
do
  intentos=$((intentos+1))
  read -p "Introduce tu número: " respuesta
  
  # Comparar el número ingresado con el número secreto
  if [[ $respuesta -lt $numero_secreto ]]; then
    echo "El número es más grande."
  elif [[ $respuesta -gt $numero_secreto ]]; then
    echo "El número es más pequeño."
  else
    echo "¡Correcto! El número era $numero_secreto."
    echo "Lo has adivinado en $intentos intento(s)."
    acertado=1
  fi
done

Haz un script llamado notas.sh que a partir de un fichero donde se recogen las calificaciones de los alumnos en los distintos módulos denominado calificaciones.txt con el siguiente formato:

Lucía Sánchez: 10, 6, 6, 5, 8
María Vargas: 9, 7, 4, 4, 7
Lucía Pérez: 7, 5, 10, 8, 4
Miguel González: 9, 7, 10, 3, 5
Miguel López: 6, 4, 6, 10, 9
Elena García: 3, 3, 3, 10, 4
Pedro Torres: 6, 4, 10, 9, 4

Se pide:

El número de alumnos matriculados.
El número de alumnos que han aprobado todos los módulos.
El número de alumnos que han suspendido sólo un módulo.
El número de alumnos que han suspendido dos módulo.
El número de alumnos que han suspendido tres módulos o más.
Indicar el número de alumnos aprobados/suspensos en porcentaje.

#!/bin/bash

archivo="calificaciones.txt"
todos_aprobados=0
un_suspenso=0
dos_suspensos=0
tres_o_mas_suspensos=0

num_alumnos=$(wc -l $archivo | cut -d' ' -f1)

for ((i=1; i<=num_alumnos; i++))
    do
    linea=$(sed -n ${i}p $archivo)
    aprobado_1=0 
    aprobado_2=0 
    aprobado_3=0 
    aprobado_4=0 
    aprobado_5=0 
    nota_1=$(echo $linea |cut -d':' -f2|cut -d',' -f1)
    if [ $nota_1 -ge 5 ]; then aprobado_1=1 ; fi

    nota_2=$(echo $linea |cut -d':' -f2|cut -d',' -f2) 
    if [ $nota_2 -ge 5 ]; then aprobado_2=1 ; fi
   
    nota_3=$(echo $linea |cut -d':' -f2|cut -d',' -f3) 
    if [ $nota_3 -ge 5 ]; then aprobado_3=1 ; fi

    nota_4=$(echo $linea |cut -d':' -f2|cut -d',' -f4) 
    if [ $nota_4 -ge 5 ]; then aprobado_4=1 ; fi

    nota_5=$(echo $linea |cut -d':' -f2|cut -d',' -f5)
    if [ $nota_5 -ge 5 ]; then aprobado_5=1 ; fi
    sum_aprobados=$((aprobado_1 + aprobado_2 + aprobado_3 + aprobado_4 + aprobado_5))

    if [ $sum_aprobados -eq 5 ];  then  todos_aprobados=$((todos_aprobados+1)) ;    fi   
    if [ $sum_aprobados -eq 4 ];  then  un_suspenso=$((un_suspenso+1)) ;    fi   
    if [ $sum_aprobados -eq 3 ];  then  dos_suspensos=$((dos_suspensos+1)) ;    fi   
    if [ $sum_aprobados -lt 3 ];  then  tres_o_mas_suspensos=$((tres_o_mas_suspensos+1)) ;    fi   
    echo -e "$linea : \033[32m$sum_aprobados \033[0mmod. aprobados "

done

porcentaje_aprobados=$(echo "scale=2; ($todos_aprobados / $num_alumnos) * 100" | bc)
porcentaje_suspensos=$(echo "scale=2; (($num_alumnos-$todos_aprobados) / $num_alumnos) * 100" | bc)

echo -e "\033[34m-------------- Resultados ---------------- \033[0m"
echo -e "Número total de alumnos matriculados:\033[32m $num_alumnos \033[0m"
echo -e "Número de alumnos que han aprobado todos los módulos:\033[32m $todos_aprobados\033[0m"
echo -e "Número de alumnos que han suspendido solo un módulo:\033[32m $un_suspenso\033[0m"
echo -e "Número de alumnos que han suspendido dos módulos:\033[32m $dos_suspensos\033[0m"
echo -e "Número de alumnos que han suspendido tres módulos o más:\033[32m $tres_o_mas_suspensos\033[0m"
echo -e "Porcentaje de alumnos aprobados:\033[35m  $porcentaje_aprobados %\033[0m"
echo -e "Porcentaje de alumnos suspensos:\033[35m  $porcentaje_suspensos %\033[0m"

Descarga el archivo calendario.dat, encontrara 543 citas donde el primer campo es el mes, el segundo campo es el día, el tercer campo es la hora y el cuarto la cita

Crea una script llamado analizar_cal.sh que considere las siguientes entradas:

Muestra un mensaje de ayuda

./analizar_cal.sh --help
salida:
Uso : analizar [OPCION]
Options:
- mes <mes>  muestra el número de citas que hay en un mes
- d <día> muestra el numero de citas que hay para ese día para todos los meses

En el caso de no dar ninguna entrada tambien mostrará el mensaje de ayuda
Muestra el número de citas que hay por mes
```
./analizar_cal.sh -mes Julio
39
```
Muestra el número de citas que hay por un determinado día para todos los meses
```
./analizar_cal.sh -d 4
11
```

Muestra el número de citas que se han producido durante todo el año de forma ordenada

./analizar_cal.sh -resumen citas | head
Reunión de trabajo.
Cita con el médico.
Llamada con un cliente.
Entrega de proyectos.
Cumpleaños de un amigo.
Clase de yoga o ejercicio.
Cena con amigos.
Aniversario de boda.
Conferencia o seminario.
Visita al dentista.

Muestra el numero de citas que hay por diferentes franjas horarias

./analizar_cal.sh -resumen horas
De 10:00-10:59 hay 87 citas
De 11:00-10:59 hay 80 citas
De 12:00-10:59 hay 99 citas
De 13:00-10:59 hay 97 citas
De 14:00-10:59 hay 79 citas
De 15:00-10:59 hay 101 citas

#!/bin/bash

function show_help() {
    echo "Uso : analizar [OPCION]"
    echo "Options:"
    echo "- mes <mes> muestra el numero de citas que hay en un mes"
    echo "- d <dia> muestra el numero de citas que hay para ese dia para todos los meses"
}
archivo=calendario.dat

if [[ $# -gt 0 ]]
then
  if [[ $1 == "--help" ]]
  then
    show_help
  fi

  if [[ $1 == "-mes" ]]
  then
    grep -c $2 $archivo 
  fi

  if [[ $1 == "-d" ]]
  then
    cat $archivo  | grep -c " $2 "         
  fi

  if [[ $1 == "-resumen" ]]
  then
    if [[ $2 == citas ]]
    then
      cat $archivo | tr -s ' ' | cut -d' ' -f4- | sort | uniq  -c | sort -r
    fi
    if [[ $2 == horas ]]
    then
      hora=$(cat $archivo | tr -s ' ' | cut -d' ' -f3 | cut -d':' -f1 | sort | uniq -c | tr -s ' '| cut -d' ' -f3)
      c=0
      for i in $hora
      do
        c=$((c+1))
        cita=$(cat $archivo | tr -s ' ' | cut -d' ' -f3 | cut -d':' -f1 | sort | uniq -c | tr -s ' '| grep $i | cut -d' ' -f2 | head -$c | tail -1)
        echo De $i:00-10:59 hay $cita citas
      done
    fi
  fi
else
 show_help
fi

Crea un script llamado rep.sh que diga el numero de veces que estan repetidos los siguientes nombres del archivo nombres.dat

#!/bin/bash

sort nombres.dat | uniq -c | sort -nr 

nlineas=$(wc -l nombres.dat | cut -d' ' -f1)
for((i=1;i<=$nlineas;i++))
do  
  A[$i]=$(head -$i nombres.dat | tail -1)
done

count=0
for((i=1;i<=$nlineas;i++))
do 
  encontrado=0
  for((j=1;j<=${#B[@]};j++))
  do
    if [ ${B[j]} == ${A[i]} ]
    then
      encontrado=1
    fi
  done
  if [[ $encontrado -eq 0 ]]
  then
    count=$((count+1))
    B[$count]=${A[i]}
  fi
done


for((i=1;i<=${#B[@]};i++))
do 
  C[$i]=0
  for((j=1;j<=${#A[@]};j++))
  do
    if [ ${B[i]} == ${A[j]} ]
    then
       C[$i]=$((${C[i]}+1))
    fi
  done
done


for((i=1;i<=${#B[@]};i++))
do  
  echo "${C[i]} ${B[i]}"
done | sort -rn

Sube al curso un script llamado monedas.sh que tire tres monedas y escriba en un archivo el resultado.

Haz que lea el archivo y obtenga el porcentaje de veces que salen 3 caras.

En el caso de que no se proporcione el número de tiradas ni el archivo, tomara por defecto el archivo llamado tiradas.dat y hará 100 tiradas.

En el caso de que no encuntre el archivo cuando lo va a leer, tomara por defecto monedas.dat, si este no existe, mostrará que no existe.

$ ./monedas.sh -help
-n <tiradas> <archivo>
-read <archivo>

#!/bin/bash

function show_help() {
    echo -e "\033[32m -help\033[0m"
    echo -e "\033[32m -n <tiradas> <archivo> \033[0m"
    echo -e "\033[32m -read <archivo> \033[0m"
}


if [[ $1 == '-help' ]]
then
  show_help
fi

if [[ $1 == '-n' ]]
then
  tiradas=${2:-100}
  outfile=${3:-monedas.dat}
  for((i=0;i<$tiradas;i++))
  do
    echo $((RANDOM % 2)) $((RANDOM % 2)) $((RANDOM % 2))
  done > $outfile
fi

if [[ $1 == '-read' ]]
then
  readfile=${2:-monedas.dat}
  if test -f $readfile
  then
    echo -e "\033[32m Leemos el archivo $readfile \033[0m"
    tres_caras=$(grep -c '1 1 1' $readfile)
    n_total=$(wc -l $readfile | cut -d ' ' -f1)
    echo -e "\033[33m Tenemos $((tres_caras * 100 / n_total))%  de tiradas con tres caras \033[0m"
  else
    echo -e "\033[31m El archivo $readfile no existe\033[0m"
  fi
fi

Crea un script en Bash llamado ips.sh que cumpla con los siguientes requisitos:

Si ejecutas el script con ./ips.sh -help, debe mostrar la siguiente ayuda:

-help                         : muestra la ayuda
-file <archivo> <número_ips>  : Crea un archivo llamado <archivo> con <número_ips>.
-find <archivo> <ip>          : Muestra cuantas veces aparece la <ip>
-read <archivo>               : Muestra de forma ordenada las IPs por número de conexiones

Si ejecutas el script sin argumentos ./ips.sh, también debe mostrar la ayuda.
Si ejecutas el ./ips.sh -file sin indicar el <número_ips> tomara por defecto 50, en el caso de no darle el <archivo> tomará por defecto ip.dat. Cada línea tendrá una IP aleatoria dentro del rango 192.168.2.0/28. La primera IP utilizable es 192.168.2.1 y la última es 192.168.2.14.
Si ejecutas el ./ips.sh -find lee el <archivo>, si no existe o no se le indica, mostrará por pantalla «El archivo no existe», en el caso de que no se proporcione <ip> mostrará por pantalla «Proporcionar ip»
Si ejecutas el ./ips.sh -read lee el <archivo>, si no existe o no se le indica, mostrará por pantalla «El archivo no existe»

#!/bin/bash

function show_help() {
    echo -e "\033[32m-help                         : muestra la ayuda\033[0m"
    echo -e "\033[32m-file <archivo> <número_ips>  : Crea un archivo llamado <archivo> con <número_ips>  \033[0m"
    echo -e "\033[32m-find <archivo> <ip>          : Muestra cuantas veces aparece la <ip>  \033[0m"
    echo -e "\033[32m-read <archivo>               : Muestra de forma ordenada las IPs por número de conexiones  \033[0m"
}


if [[ $1 == '-help' ]]
then
  show_help
fi

if [[ $# -eq 0 ]]
then
  show_help
fi

if [[ $1 == '-file' ]]
then
  tiradas=${3:-50}
  outfile=${2:-ip.dat}
  for((i=0;i<$tiradas;i++))
  do
    echo 192.168.2.$((RANDOM % 14 + 1))
  done > $outfile
fi

if [[ $1 == '-find' ]]
then
  readfile=$2
  ip=$3
  if test -z $3
  then
      echo -e "\033[31m Proporcionar ip\033[0m"
  else
    if test -f $readfile
    then
      echo -e "\033[32m Leemos el archivo $readfile \033[0m"
      grep -c $ip $readfile
    else
      echo -e "\033[31m El archivo $readfile no existe\033[0m"
    fi
  fi
fi
if [[ $1 == '-read' ]]
then
  readfile=$2
  if test -f $readfile
  then
    echo -e "\033[32m Leemos el archivo $readfile \033[0m"
    cat $readfile | sort | uniq -c | sort -rn
  else
    echo -e "\033[31m El archivo $readfile no existe\033[0m"
  fi
fi

Sube al curso un script llamado dados.sh que obtenga dos números aleatorios entre el 1 y el 6, obtén la suma de los dos dados, Haz que salga por pantalla el numero de tiradas y el porcentaje de veces que sale cada una.

Haz que el número de tiradas lo reciba como un argumento, el caso de que no reciba ningún argumento haz que haga 1000 tiradas

$ ./dados.sh
De 1000 tiradas : 2(1%) 3(7%) 4(10%) 5(12%) 6(14%) 7(17%) 8(14%) 9(12%) 10(10%) 11(7%) 12(1%)

#!/bin/bash

tiradas=${1:-1000}

for ((i = 2; i <= 12; i++)); do
  frecuencias[$i]=0
done

for ((i = 1; i <= tiradas; i++)); do
  dado1=$((RANDOM % 6 + 1))
  dado2=$((RANDOM % 6 + 1))
  suma=$((dado1 + dado2))
  frecuencias[$suma]=$((frecuencias[$suma]+1))
done

echo "De $tiradas tiradas:"
output=""
for ((i = 2; i <= 12; i++)); do
  porcentaje=$((frecuencias[$i] * 100 / tiradas))
  output+="$i(${porcentaje}%) "
done

echo "$output"

Gestión de usuarios locales#

Crea un script llamado usuarios.sh, utiliza para ello un clon enlazado de la «MV Ubuntu Server 24.04»

./usuarios.sh -help
  usuarios.sh -addgroup <grupo>         : Crea un grupo si no existe
  usuarios.sh -delgroup <grupo>         : Elimina un grupo si existe
  usuarios.sh -adduser <usuario> [grupo]: Crea un usuario en el grupo especificado
                                        : Si el grupo no existe lo crea primero
                                        : Si no damos grupo usa por defecto el grupo usuario1
  usuarios.sh -deluser <usuario>        : Elimina un usuario si existe
  usuarios.sh -lista                    : Lista todos los grupos y sus usuarios

En el caso de ejecutar ./usuarios.sh sin argumentos obtendremos el mensaje de ayuda.

Chequea tu script con las siguientes características:

cat usuarios.sh
for g in GA GB GC GD
do
  ./usuarios.sh -addgroup $g
  for u in 01 02 03 04
    do
    usuario=usuario_${g}_${u}
    ./usuarios.sh -adduser ${usuario} ${g}
  done
done
./usuarios.sh -lista

./usuarios.sh -help
El script muestra una ayuda con las opciones que puede tiene

#!/bin/bash

function show_help() {
    echo "Uso del script:"
    echo "./usuarios.sh -addgroup <grupo>         : Crea un grupo si no existe"
    echo "./usuarios.sh -delgroup <grupo>         : Elimina un grupo si existe"
    echo "./usuarios.sh -adduser <usuario> [grupo]: Crea un usuario en el grupo especificado (o en uno con su mismo nombre)"
    echo "./usuarios.sh -deluser <usuario>        : Elimina un usuario si existe"
    echo "./usuarios.sh -lista                    : Lista todos los grupos y sus usuarios"
}

if [[ $# -gt 0 ]]
then
  if [[ $1 == "-addgroup" ]]
  then
    if [[ $(grep -c $2 /etc/group) -gt 0 ]]
    then
      echo "No se crea el grupo, el grupo $2 existe."
    else
      echo "Creamos el grupo $2"
      groupadd $2
    fi
  fi
  if [[ $1 == "-delgroup" ]]
  then
    groupdel $2
  fi

  if [[ $1 == "-adduser" ]]
  then
    usuario=$2
    grupo=${3:-$usuario}
    echo "creamos el $usuario en $grupo"
    if [[ $(grep -c $usuario /etc/passwd) -gt 0 ]]
    then
      echo "No se crea el usuario, el usuario $usuario ya existe."
    else
      if [[ $(grep -c $grupo /etc/group) -eq 0 ]]
      then
        groupadd $grupo
        echo "Creamos el grupo $grupo"
      fi
      useradd -g $grupo -d /home/$usuario -m -s /bin/bash -p $( mkpasswd -m sha-512 -s cambiame) $usuario
      echo "Usuario $usuario creado en el grupo $grupo con contraseña por defecto 'cambiame'."
    fi
  fi
  if [[ $1 == "-deluser" ]]
  then
    if [[ $(grep -c $2 /etc/passwd) -gt 0 ]]
    then
      userdel -r $2
      echo "Usuario $2 eliminado."
    else
      echo "No se borra el usuario, el usuario $2 no existe."
    fi
  fi
  if [[ "$1" == "-lista" ]]
  then
    #solo listamos los grupos que tienen usuarios
    for g in $(cut -d':' -f1 /etc/group)
    do
      if [[ $(members $g ) != "" ]]
      then
        echo ----- $g------
        members $g
      fi
    done
  fi

else
  show_help
fi

Genera la siguiente lista de usuarios en el archivo lista.dat

for((i=0;i<40;i++))
do
  R=$RANDOM
  echo tunombre_$R G$(($R%4))
done > lista.dat

Crea un script llamado crear_usuarios_lista.sh que genere por defecto los usuarios que encuentra en el archivo lista.dat, con la contraseña cambiame, haz que si recibe el nombre de otro archivo como lista lo utilice. En el caso de que el grupo no exista haz que lo cree en el sistema
Crea otro script llamado borrar_usuarios_lista.sh que borre los usuarios que aparecen en el archivo lista.dat, haz que utilice este archivo por defecto en el caso de no recibir ningun archivo.
Crea otro script llamdo crear_usuarios_grupo_lista.sh que lea solo la primera columna de un archivo llamado nombre_grupo.dat, creará todos los usuarios dentro del grupo llamado nombre_grupo, en el caso de que no exista creara primero el grupo.
Crea otro script llamdo borrar_usuarios_grupo_lista.sh que lea solo la primera columna de un archivo llamado nombre_grupo.dat, borrará todos los usuarios que encuentre en la lista, al final y sólo en el caso de que el grupo se haya quedado bacio se borrará tambien el grupo.

#!/bin/bash

#Vamos a crear los usuarios que aparecen en la lista.dat
#$cat listda.dat
# usuario1 Grupo1
# usuario2 Grupo2
# usuario3 Grupo1

archivo=${1:-lista.dat}

for usuario in $(cat $archivo | cut -d' ' -f1 )
do
  grupo=$(grep $usuario $archivo | cut -d' ' -f2)
  if [[ $(grep -c $usuario /etc/passwd) -gt 0 ]]
  then
    echo -e "\033[31m No se crea el usuario, el usuario $usuario ya existe. \033[0m"
  else
    if [[ $(grep -c $grupo /etc/group) -eq 0 ]]
    then
      groupadd $grupo
      echo -e "\033[34m Creamos el grupo $grupo \033[0m"
    fi
    useradd -g $grupo -d /home/$usuario -m -s /bin/bash -p $( mkpasswd -m sha-512 -s cambiame) $usuario
    echo -e "\033[34m Creamos el usuario $usuario en el grupo $grupo con contraseña por defecto 'cambiame'.\033[0m"
  fi
done

#!/bin/bash

#Vamos a crear los usuarios que aparecen en la lista.dat

archivo=${1:-lista.dat}


for usuario in $(cat $archivo | cut -d' ' -f1 )
do
  if [[ $(grep -c $usuario /etc/passwd) -gt 0 ]]
  then
    echo -e "\033[34m Borramos el $usuario \033[0m"
    userdel -r $usuario
  else
    echo -e "\033[31m El usuario $usuario no existe \033[0m"
  fi
done

#!/bin/bash

#Vamos a crear los usuarios que aparecen en el archvio grupo.dat

if [[ $# == 0 ]]
then
  echo -e  "\033[31m El primer argumento es el archivo con el nombre del grupo.dat \033[0m"
else
  if test -e $1
  then
    archivo=$1
    echo -e "\033[33m Leemos el archivo $archivo \033[0m"
    grupo=$(echo $archivo | sed 's/.dat//')
    for usuario in $(cat $archivo | cut -d' ' -f1 )
    do
      if [[ $(grep -c $usuario /etc/passwd) -gt 0 ]]
      then
        echo -e "\033[31m No se crea el usuario, el usuario $usuario ya existe.\033[0m"
      else
        if [[ $(grep -c $grupo /etc/group) -eq 0 ]]
        then
          groupadd $grupo
          echo -e "\033[34m Creamos el grupo $grupo \033[0m"
        fi
        echo  -e "\033[34m Creamos el usuario $usuario en el grupo $grupo \033[0m"
        useradd -g $grupo -d /home/$usuario -m -s /bin/bash -p $( mkpasswd -m sha-512 -s cambiame) $usuario
        echo -e "\033[34m Usuario $usuario creado en el grupo $grupo con contraseña por defecto 'cambiame'.\033[0m"
      fi
    done
  else
    echo -e "\033[31m El archivo $1 no existe \033[0m"
  fi
fi

#!/bin/bash

if [[ $# == 0 ]]
then
  echo -e  "\033[31m El primer argumento es el archivo con el nombre del grupo.dat \033[0m"
else
  if test -e $1
  then
    archivo=$1
    echo -e "\033[33m Leemos el archivo $archivo \033[0m"
    grupo=$(echo $archivo | sed 's/.dat//')
    idg=$(grep $grupo /etc/group | cut -d':' -f3)
    for usuario in $(cat $archivo | cut -d' ' -f1 )
    do
      if [[ $(grep -c $usuario /etc/passwd) -gt 0 ]]
      then
        userdel -r $usuario
        echo  -e "\033[34m Borramos el usuario $usuario $grupo \033[0m"
      else
        echo -e "\033[31m No se borra el usuario, el usuario $usuario no existe.\033[0m"
      fi
    done
    n_usuarios_grupo=$(cat /etc/passwd | cut -d':' -f4 | sort | uniq -c | grep $idg | tr -s ' ' | cut -d' ' -f2)
    if [[ $n_usuarios_grupo -eq 0 ]]
    then
      echo -e  "\033[34m Borramos el $grupo ya que no tiene usuarios \033[0m"
      groupdel $grupo
    else
      echo -e  "\033[31m No se borra el  $grupo ya que tiene $n_usuarios_grupo  usuarios \033[0m"
    fi
  else
    echo -e "\033[31m El archivo $1 no existe \033[0m"
  fi
fi

Gestión de usuarios LDAP#

Crea un script llamado usuarios_ldap.sh, utiliza para ello un clon enlazado de la “MV Ubuntu Server 24.04” con un ldap configurado aqui

Uso del script:
./usuarios_ldap.sh -addgroup <grupo>         : Crea un grupo si no existe
./usuarios_ldap.sh -delgroup <grupo>         : Elimina un grupo si existe
./usuarios_ldap.sh -lsgroup                  : Elimina un grupo si existe
./usuarios_ldap.sh -adduser <usuario> [grupo]: Crea un usuario en el grupo especificado
./usuarios_ldap.sh -deluser <usuario>        : Elimina un usuario si existe
./usuarios_ldap.sh -lista                    : Lista todos los grupos y sus usuarios
./usuarios_ldap.sh -lsuser                   : Elimina un grupo si existe

#!/bin/bash
LDAP="dc=ldap,dc=tunombre,dc=local"
LDAPadmin="cn=admin,$LDAP"
password=alumno
passwd_defecto_usuario=cambiame

function crear_grupo(){
NAMEG=$1       #GA
NUMBERGID=$2   #501

cat << EOF > grupo.ldif
dn: cn=${NAMEG},ou=grupos,$LDAP
objectClass: posixGroup
cn: ${NAMEG}
gidNumber: ${NUMBERGID}
EOF

ldapadd -x -D $LDAPadmin -w $password -f grupo.ldif
rm -fr grupo.ldif
}

function crear_usuario(){
NAME=$1      #tunombre1
NUMBERID=$2  #1001
NUMBERGID=$( ldapsearch -xLLL -D $LDAPadmin -w $password -b $LDAP cn=$3 gidNumber | grep  gid | cut -d':' -f2)

cat << EOF > usuarios.ldif
dn: uid=${NAME},ou=usuarios,$LDAP
objectClass: inetOrgPerson
objectClass: posixAccount
objectClass: shadowAccount
uid: ${NAME}
cn: ${NAME}
sn: ${NAME}
gidNumber: ${NUMBERGID}
uidNumber: ${NUMBERID}
userPassword: $passwd_defecto_usuario
homeDirectory: /home/$NAME
loginShell: /bin/bash
EOF

ldapadd -x -D $LDAPadmin -w $password -f usuarios.ldif
#rm -fr usuarios.ldif
}

function show_help() {
    echo -e "\033[34m Uso del script:\033[0m"
    echo -e "\033[34m ./usuarios_ldap.sh -addgroup <grupo>         : Crea un grupo si no existe\033[0m"
    echo -e "\033[34m ./usuarios_ldap.sh -delgroup <grupo>         : Elimina un grupo si existe\033[0m"
    echo -e "\033[34m ./usuarios_ldap.sh -lsgroup                  : Elimina un grupo si existe\033[0m"
    echo -e "\033[34m ./usuarios_ldap.sh -adduser <usuario> [grupo]: Crea un usuario en el grupo especificado \033[0m"
    echo -e "\033[34m ./usuarios_ldap.sh -deluser <usuario>        : Elimina un usuario si existe\033[0m"
    echo -e "\033[34m ./usuarios_ldap.sh -lista                    : Lista todos los grupos y sus usuarios\033[0m"
    echo -e "\033[34m ./usuarios_ldap.sh -lsuser                  : Elimina un grupo si existe\033[0m"
}


if [[ $# -gt 0 ]]
then
  if [[ $1 == "-addgroup" ]]
  then
    if [[ $(ldapsearch -xLLL -b $LDAP cn=$2 | grep -c 'ldap') -gt 0 ]]
    then
      echo -e "\033[31m No se crea el grupo, el grupo $2 existe. \033[0m"
    else
      echo -e "\033[34m Creamos el grupo $2 \033[0m"
      #tomamos el ultimo gidNumbrer:
      gidN=$(ldapsearch -xLLL -b $LDAP | grep gidNumber | cut -d':' -f2 | tail -1)
      if [ -z $gidN ] #-z indica que la variable esta vacía
      then
        gidN=500
      fi
      gidN=$((gidN+1))
      crear_grupo $2 $gidN
    fi
  fi


  if [[ $1 == "-delgroup" ]]
  then
    if [[ $(ldapsearch -xLLL -b $LDAP cn=$2 | grep -c 'ldap') -gt 0 ]]
    then
      ldapdelete -x -w $password -D $LDAPadmin "cn=$2,ou=grupos,$LDAP"
      echo -e "\033[34m Borramos el grupo $2 \033[0m"
    else
      echo -e "\033[31m No se borra el grupo, el grupo $2 no existe. \033[0m"
    fi
  fi

  if [[ $1 == "-lsgroup" ]]
  then
    ldapsearch -xLLL -D $LDAPadmin -w $password -b $LDAP "(objectClass=posixGroup)" cn gidNumber
  fi
  if [[ $1 == "-adduser" ]]
  then
    if [[ $(ldapsearch -xLLL -b $LDAP cn=$2 | grep -c 'ldap') -gt 0 ]]
    then
      echo -e "\033[31m No se crea el usuario, $2 existe. \033[0m"
    else
      #tomamos el ultimo gidNumbrer:
      uidN=$(ldapsearch -xLLL -b $LDAP | grep uidNumber | cut -d':' -f2 | tail -1)
      if [ -z $uidN ] #-z indica que la variable esta vacía
      then
        uidN=1000
      fi
      uidN=$((uidN+1))
      grupo=$3
      if [ -z $grupo ]
      then
        echo -e "\033[31m No se crea el usuario, necesitamos un grupo. \033[0m"
      else
        echo -e "\033[34m Creamos el usuario $2 \033[0m"
        crear_usuario $2 $uidN $grupo
      fi
    fi
  fi


  if [[ $1 == "-deluser" ]]
  then
    if [[ $(ldapsearch -xLLL -b $LDAP uid=$2 | grep -c 'ldap') -gt 0 ]]
    then
      ldapdelete -x -w $password -D $LDAPadmin "uid=$2,ou=usuarios,$LDAP"
      echo -e "\033[34m Borramos el usuario $2 \033[0m"
    else
      echo -e "\033[31m No se borra el usuario, el usuario $2 no existe. \033[0m"
    fi
  fi



  if [[ $1 == "-lsuser" ]]
  then
    ldapsearch -xLLL -D $LDAPadmin -w $password -b $LDAP "(objectClass=posixAccount)" cn uidNumber
  fi

else
  show_help
fi

Crea un script llamado crear_usuarios_lista_ldap.sh, haz que todos los usuarios se lean de un archivo llamado grupo.dat. Haz que todos los usuarios pertenezcan al grupo con el mismo nombre que el archivo sin la extensión .dat. En el caso de que no exista el grupo haz que se cree.

En el archivo grupo.dat, hay una lista de emails, haz que se creer el usuario correspondiente al email, es decir usuario1@gmail.com creara el usuario usuario1

Uso del script:
./crear_usuarios_lista_ldap.sh grupo.dat

head -2 grupo.dat
usuario1@gmail.com
usuario2@gmail.com

#!/bin/bash

Crea un script llamado borrar_usuarios_lista_ldap.sh, cuando termmine de borrar todos los usuarios del archivo grupo.dat comprobará si el grupo no tiene usuarios, en ese caso lo borrará también.

Uso del script:
./crear_usuarios_lista_ldap.sh grupo.dat

head -2 grupo.dat
usuario1@gmail.com
usuario2@gmail.com

#!/bin/bash

Ejercicios de shell scripting

Contenido

Ejercicios de shell scripting#

Gestión de usuarios locales#

Gestión de usuarios LDAP#