Reto 7

He tomado el codigo del reto6.sh y le aplicado lo aprendido en cuanto a funciones.

# ! /bin/bash
 # Programa para cumplir con el reto#3
 #Arnoldo Alvarez
 
 opcion=""
 numA=0
 numB=0
 numC=0
 #telRegex= '^\(?([0-9]{3})\)?([0-9]{3})[.]?([0-9]{4})$' #Solo acepta el formato telefonico (xxx)xxx.xxxx Ej:(706)612.4602
 telRegex2='^\([0-9]\{3\}\)\([0-9]\{3\}\)\([0-9]*\)/(\1) \2 . \3/$'
 pathArchivo=""
 aritmetica=""
 funcion=""
 phone=""
 respTel=""
 respBackup=""
 FILE=log.txt
 FILE2=Zip.zip
 DATE=`date +%y%m%d`
 TIME=`date +%H%M%S`
 
 coronavirus_guidelines() {
 
          echo -e "\nLo que debes hacer es lo siguiente:
               a) Lavarse las manos frecuentemente.
               b) Toser o estornudar al interior de  tu codo.
               c) No tocarse la cara.
               d) Mantener cierta distancia social.
               e) Quedarse voluntariamente en casa."
 
               echo "$DATE-$TIME --- Guidelines de CoronaVirus consultadas" >> logs_reto7/$NEWFILE
 
      read -n 1 -s -r -p "Presione [ENTER] para continuar..."
  }
Math_Function () {
 
  echo    "Funciones Aritmeticas disponibles
                      1.- Sumar
                      2.- Multiplicar
                      3.- Dividir"
           echo -e "\n"
           read -p "Escoja la funcion Aritmetica: " aritmetica
 
           case $aritmetica in
 
                "1")  funcion="suma"
                      numC=$((numA + numB));;
                "2")  funcion="Multiplicacion"
                     numC=$((numA * numB));;
                "3")  funcion="Division"
                      numC=$((numA / numB));;
                  *)  funcion="Funcion No definida"
                      echo "$DATE-$TIME --- Opcion No encontrada,Funcion Matematica NO realizada"   >> logs_reto6/$NEWFILE
                      echo "Opcion incorrecta";;
           esac
 
              echo "Resultado Matematico de la $funcion: $numC "
              echo "$DATE-$TIME --- Usuario realiza funcion matematica $funcion:$numC" >> logs_reto7/$NEWFILE
 
      read -n 1 -s -r -p "Presione [ENTER] para continuar..."
 
 }
Phone_Format () {
 
      echo "$DATE-$TIME --- Usuario escoge chequear formato de numero telefonico" >> logs_reto7/$NEWFILE
              read -p "Ingrese numero telefonico: " telefono
 
              if [[ $telefono =~ $telRegex2 ]]; then
                  echo "Formato correcto dentro de los EEUU"
              else
              phone=$telefono
              plainPhone=$(echo $phone | sed "s/[()-.]//g")
              echo "Formato Incorrecto dentro de los EEUU"
              read -n1 -p "Convertir al formato (123)456.7890 s/n:  "  respTel
              echo  -e "\n"
               if [ $respTel = "s" ]; then
                formatedPhone2=$(echo $plainPhone | sed "s/\([0-9]\{3\}\)\([0-9]\{3\}\)\([0-9]*\)/(\1) \2 . \3/")
                echo "Numero convertido: $formatedPhone2 "
                echo "$DATE-$TIME --- Usuario cambia formato del Numero Telefonico $telefono" >> logs_reto7/$NEWFILE
               else
 
                   echo "$DATE-$TIME --- Usuario responde NO para cambiar formato de  $telefono" >> logs_reto7/$NEWFILE
                   echo "Volviendo al Menu Principal..."
               fi
              fi
 
      read -n 1 -s -r -p "Presione [ENTER] para continuar..."
 }
Directory_Search () {
 
      if [[ -d $dirPath  ]]; then
 
                  echo "$DATE-$TIME --- Usuario consulta satisfactoriamente el directorio $dirPath" >> logs_reto7/$NEWFILE
                  echo "El directorio $dirPath SI Existe"
 
                  else
                      echo "El directorio NO Existe o NO es un directorio"
                      echo "$DATE-$TIME --- Usuario No encuentra $dirPath" >> logs_reto7/$NEWFILE
              fi
 
      read -n 1 -s -r -p "Presione [ENTER] para continuar..."
 }
 
 File_Search () {
 
     if [[ -e $filePath  ]]; then
               echo "$DATE-$TIME --- Usuario consulta el archivo $filePath" >> logs_reto7/$NEWFILE
               cat $filePath
           else
               echo "No se encuentra el archivo o Nombre de archivo Incorrecto"
               echo "$DATE-$TIME --- Usuario No encuentra $filePath" >> logs_reto7/$NEWFILE
           fi
 
      read -n 1 -s -r -p "Presione [ENTER] para continuar..."
 
 }
Backup_Shit () {
 
     if [[ $respBackup = "s" ]]; then
               echo -e  "\ncreando archivo tar..."
               sleep 2
               tar -cvf logs_reto7/backup_`date +%Y%m%d`_`date +%H%M%S`.tar logs_reto7/
 
               echo -e "\nCreando archivo ZIP..."
               echo "Debera introducir una Clave de Seguridad..."
               sleep 2
               zip -e logs_reto7/zip_`date +%Y%m%d`_`date +%H%M%S`.zip /shellCourse/logs_reto7/*.tar
 
               echo "Transfieriendo archivo ZIP..."
               echo "Clave de Administrador para Transferencias"
               sleep 2
               rsync -avz /shellCourse/logs_reto7/*.zip [email protected]:/$HOME/backup_logs_reto7/
               echo "$DATE-$TIME --- Usuario ejecutando proceso de Respaldo" >> logs_reto7/$NEWFILE
               sleep 3
               echo -e  "\nBackup Realizado con Exito..."
           else
 
               echo "$DATE-$TIME --- Usuario cancela proceso de Respaldo " >> logs_reto7/$NEWFILE
               echo -e "\nSaliendo del modulo de Respaldos..."
               sleep 3
           fi
  }
 #Se crea un archivo .log con fecha y hora y se mueve a un directorio de logs_reto5
 NEWFILE=${FILE%.*}_`date +%Y%m%d`_`date +%H%M%S`.${FILE#*.}
 touch $NEWFILE
 mv $NEWFILE logs_reto6/
  #echo "El archivo $NEWFILE fue creado con exito"
 
 
 while :
 do
     clear
     echo "archivo: $NEWFILE"
 echo "Las opciones son las siguientes\n
         1.- Para Saber como evitar CoronaVirus
         2.- Realizar funciones numericas
         3.- Para verificar formato de numero telefonico
         4.- Para verificar un directorio
         5.- Ver contenido de un Archivo
         6.- Hacer Respaldo de Logs
         7.- salir"
 
 echo -e "\n"
 read -n1  -p "Introduzca su Opcion: " opcion
case $opcion in
 
     "1") coronavirus_guidelines
 
          ;;
 
     "2") echo -e "\nIntroduzca el numero A: "
          read
          numA=$REPLY
          echo -e "Introduzca el numero B: "
          read
          numB=$REPLY
          Math_Function $numA $numB
 
          ;;
 
 
      "3")   echo -e "\n"
             Phone_Format
             ;;
"4") echo -e "\n"
          read -p "Ingrese la ruta de un directorio: " dirPath
          Directory_Search $dirPath
         ;;
 
      "5")echo -e "\n"
          read -p "Ingrese la ruta del archivo: " filePath
          File_Search $filePath
          ;;
 
      "6")echo -e "\n"
          read -n1 -p "Desea hacer Backup del Directorio logs_reto7 s/n: " respBackup
          Backup_Shit $respBackup
 
          ;;
 
      "7")   echo -e "\n"
             echo -e "Saliendo..."
             echo "$DATE-$TIME --- Usuario sale de la aplicacion" >> logs_reto7/$NEWFILE
             exit 0
 
             ;;
 
       *) echo "Opcion Incorrecta, Lo sentimos"
 
 
       esac
 done

reto 7

opcion=0
fechaActual=`date +%Y%m%d`

#Función para instalar postgres
instalar_postgres () {
	echo -e "\n Verificar instalación de postgres..."
	verifyInstall=$(which psql)
	if [ $? -eq 0 ]; then
		echo -e "\n Postgres ya se encuentra instalado"
	else
		read -s -p "Ingresar contraseña de sudo:" password
		read -s -p "Ingresar contraseña a utilizar en postgres:" passwordPostgres
		echo "$password" | sudo -S apt update
		echo "$password" | sudo -S apt-get -y install postgresql postgresql-contrib
		sudo -u postgres psql -c "ALTER USER postgres WITH PASSWORD '{$PASSWORDpOSTGRES}';"
		echo "$password"| sudo -S systemctl enable postgresql.service
		echo "$password"| sudo -S systemctl start postgresql.service
	fi
	read -n1 -s -r -p "PRESIONE [ENTER] para continuar..."

}

desinstalar_postgres () {
echo "Desintalar postgres"
echo -e "\n"
read -s -p "Ingresar contraseña de sudo:" password
echo "$password"| sudo -S systemctl stop postgresql.service
echo "$password"| sudo -S apt-get -y --purge remove postgresql\*
echo "$password"| sudo -S rm -f /etc/postgresql
echo "$password"| sudo -S rm -f /etc/postgresql-common
echo "$password"| sudo -S rm -f /var/lib/postgresql
echo "$password"| sudo -S userdel -r postgres
echo "$password"| sudo -S groupdel postgresql
read -n1 -s -r -p "PRESIONE [ENTER] para continuar..."

}

sacar_respaldo () {
	echo "Listar las bases de datos"
	sudo -u postgres psql -c "\l"
	read -p "Elegir la base de datos a respaldar:" bddRespaldo
	echo -e "\n"
	if [ -d "$1" ]; then
		echo "Establecer permisos al directorio"
		echo "$password"| sudo -S chmod 755 $1
		echo "Realizando respaldo ... "
		sudo -u postgres pg_dump -Fc $bddRespaldo > "$1/bddRespaldo$fechaActual.bak"
		echo "Respaldo realizado correctamente en la ubicación: $1/bddRespaldo$fechaActual.bak"
	else
		echo "El directorio $1 no existe"
	fi

	read -n1 -s -r -p "PRESIONE [ENTER] para continuar..."
}


restaurar_respaldo () {
	echo "Listar respaldos"
	ls -1 $1/*.bak
	read -p "Elegir el respaldo a restaurar" respaldoRestaurar
	echo -e "\n"
	read -p "Ingrese el nombre de la base de datos destino:" bddDestino
	# Verificar si la bdd existe 
	verifyBdd=$(sudo -u postgres psql -lqt |cut -d \| -f 1 | grep -wq $bddDestino)
	if [ $? -eq 0 ];then
		echo "Restaurando en la dbb destino: $bddDestino"
	else
		sudo -u postgres psql -c "create database $bddDestino"
	fi

	if [ -f "$1/$respaldoRestaurar" ]; then
		echo "Restaurando respaldo..."
		sudo -u postgres pg_restore -Fc -d $bddDestino "$1/$respaldorestaurar"
		echo "Listar la base de datos"
		sudo -u postgres psql -c "\l"
	else
		echo "El respaldo $respaldoRestaurar no existe"
	fi
	read -n1 -s -r -p "PRESIONE [ENTER] para continuar..."

}

memoria () {
	echo -e "\nMemoria del servidor"
	free -m
}

uso_cpu () {
	echo -n "\nestadisticas de uso de cpu"
	vmstat 1 2
}

uso_disco () {
	echo -e "\nuso disco"
	df -h
}

procesos_memoria () {
	echo -e "\nlos procesos en memoria"
	ps -fea
}

usuarios_locales () {
	echo -e "\nusuario locales"
	cat /etc/passwd
}


while :
do
	#Limpiar pantalla
	clear
	#desplegar menu de opciones
	echo "_________________________________________"
	echo "PGUTIL - Programa de utilidad de Postgres"
	echo "_________________________________________"
	echo "              MENU PRINCIPAL             "
	echo "_________________________________________"
	echo "1. Instalar Postgres"
	echo "2. Desintalar Postgres"
	echo "3. Sacar un respaldo"
	echo "4. Restar respaldo"
	echo "5. ver memoria"
	echo "6. Uso CPU"
	echo "7. Disco"
	echo "8. Procesos memoria"
	echo "9. Usuarios locales"
	echo "10. Salir"

	#Leer los datos de usuario
	read -n2 -p "Ingrese una opción [1-10]:" opcion

	#validar la opción ingresada
	case $opcion in
		1) instalar_postgres
			sleep 3
			;;
		2) desinstalar_postgres
			sleep 3
			;;
		3) read -p "Directorio Backup" directorioBackup
			sacar_respaldo $directorioBackup

			sleep 3
			;;
		4) read -p "Directorio de Respaldo:" directorioRespaldos
			restaurar_respaldo $directorioRespaldos
			sleep 3
			;;

		5) memoria
			sleep 3
			;;
		6) uso_cpu
			sleep 3
			;;
		7) uso_disco
			sleep 3
			;;
		8) procesos_memoria
			sleep 3
			;;
		9) usuarios_locales
			sleep 3
			;;

		10) echo -e "\nSalir del programa"
			exit 0
			;;
	esac
done

#!/bin/bash
#Programa que permite manejar las utilidades de Postgres
#Autor= Marcelo Roman

opcion=0
fechaActual=`date +%Y%m%d`

#Funcion para instalar postgres
instalar_postgres () {
    echo -e "\n Verificar instalacion postgres"
    verifyInstall=$(which psql)
    if [ $? -eq 0 ]; then
	    echo -e "\n Postgres ya se encuentra instalado en el equipo"
	else
	    read -s -p "Ingresar contrasenha root" password
	    read -s -p "Ingresar contrasenha a utilizar en postgres" passwordPostgres
	    echo "$password" | apt update
	    echo "$password" | apt-get install postgresql postgresql-contrib
	    sudo postgres psql -C "ALTER USER postgres WITH PASSWORD" '{$passwordPostgres}'
	    echo "$password" | su systemctl enable postgresql.service
   	    echo "$password" | su systemctl start postgresql.service
    fi
	    read -n 1 -s -r -p "PRESIONE [ENTER] para continuar..."
}

#Funcion para desinstalar postgres
desinstalar_postgres () {
        read -n1 -p "Desea realmente desinstalar postgres [S/N]: " confirmar
    	echo -e "\n"
	if [ $confirmar = 'S' ] || [ $confirmar = 's' ]; then
	echo -e "\nDesinstalar postgres..."
	read -s -p "Ingresar contrasenha root: " password
	echo -e "\n"
	echo "$password" | sudo systemctl stop postgresql.service
	echo "$password" | sudo apt-get -y --purge remove postgresq\*
	echo "$password" | sudo rm -rf /etc/postgresql
	echo "$password" | sudo rm -rf /var/lib/postgresql
	echo "$password" | sudo usedel -r postgres
       echo "$password" | sudo groupdel postgresql
	echo -e "\nDesinstalado postgres"
    elif  [ $confirmar = 'N' ] || [ $confirmar = 'n' ]; then
	echo -e "\n"
	read -n 1 -s -r -p "PRESIONE [ENTER] para continuar..."
	else
	echo "opcion ingresada no valida"
    fi        
}
#Funcion para sacar un respaldo
sacar_respaldo () {
    echo "Listar las base de datos"
    sudo -u postgresql psql -c "\l"
    read -p "Elegir las base de datos a respaldar: " bddRespaldo
    echo -e "\n"
    if [ -d "$1" ]; then
	   echo "Establecer permisos directorio"
	   echo "$password" | sudo -S chmod 755 $1
	   echo "Realizando respaldo..."
	   sudo -u postgres pg_dump -Fc $bddRespaldo > "$1/bddRespaldo$fechaActual.bak"
	   echo "Respaldo realizado correctamente en la ubicacion:$1/bddRespaldo$fechaActual.bak"
           read -n 1 -s -r -p "PRESIONE [ENTER] para continuar..."
    else
	echo "El directorio $1 no existe"
fi
}

#Funcion restaurar un respaldo
restaurar_respaldo () {
    echo "Listar respaldos"
    read -p "Ingresar el directorio donde estan los respaldos: " directorioBackup
    ls -la $directorioBackup
    read -p "Elegir el resplado a restaurar" respaldoRestaurar
    echo -e "\n"
    read -p  "Ingrese el nombre de la base de datos destino: " bddDestino
    #verificar si la bdd existe
    verifyBdd=$(sudo -u postgres psql -lqt | cut-d | -f 1 | grep -wq $bddDestino)
    if [ $? -eq 0  ]; then
	echo "Restaurando en la bdd destino: $bddDestino"
    else
	su -u postgres psql -c "create database $bddDestino"
    fi
    if [ -f "$1/$respaldoRestaurar"  ]; then
	echo "Restaurando respaldo ..."
	sudo -u postgres pq_restore -Fc -d $bddDestino "$DirectorioBackup/$respaldoRestaurar"
	echo "Listar la base de datos"
	sudo -u postgres psql -c "\l"
    else
	echo "El respaldo $restaurarRespaldo no existe"
    fi
    read -n 1 -s -r -p "PRESIONE [ENTER] para continuar..."
}

while :
do
    #Limpiar la pantalla
    clear
    #Desplegar el menu de opciones
    echo "#------------------------------------------#"
    echo "#PGUTIL - Programa de Utilidad de Postgres #"
    echo "#------------------------------------------#"
    echo "#              Menu Principal              #"
    echo "#------------------------------------------#"
    echo "# 1. Instalar Postgres                     #"
    echo "# 2. Desinstalar Postgres                  #"
    echo "# 3. Sacar un respaldos                    #"
    echo "# 4. Restaurar respaldo                    #"
    echo "# 5. Salir                                 #"
    echo "#------------------------------------------#"
    #Leer los datos del usuario - capturar informacion
    read -n1 -p "Ingrese una opcion [1-5]:" opcion
    echo -e "\n"

    #Validad la opcion ingresada
    case $opcion in
	1)
	    instalar_postgres
	    sleep 3
	    ;;
	2)
	    desinstalar_postgres
	    sleep 3
	    ;;
        3)
	    sacar_respaldo
            sleep 3
	    ;;
        4)
	    restaurar_respaldo
            sleep 3
	    ;;
        5)
            echo -e "\nSalir del programa"
            exit 0
            ;;
	*)
	    echo -e "\nOpcion no valida"
	    sleep 1
	    ;;
	esac
done```

        echo"███████████████████████████"
        echo"███████▀▀▀░░░░░░░▀▀▀███████"
        echo"████▀░░░░░░░░░░░░░░░░░▀████"
        echo"███│░░░░░░░░░░░░░░░░░░░│███"
        echo"██▌│░░░░░░░░░░░░░░░░░░░│▐██"
        echo"██░└┐░░░░░░░░░░░░░░░░░┌┘░██"
        echo"██░░└┐░░░░░░░░░░░░░░░┌┘░░██"
        echo"██░░┌┘▄▄▄▄▄░░░░░▄▄▄▄▄└┐░░██"
        echo"██▌░│██████▌░░░▐██████│░▐██"
        echo"███░│▐███▀▀░░▄░░▀▀███▌│░███"
        echo"██▀─┘░░░░░░░▐█▌░░░░░░░└─▀██"
        echo"██▄░░░▄▄▄▓░░▀█▀░░▓▄▄▄░░░▄██"
        echo"████▄─┘██▌░░░░░░░▐██└─▄████"
        echo"█████░░▐█─┬┬┬┬┬┬┬─█▌░░█████"
        echo"████▌░░░▀┬┼┼┼┼┼┼┼┬▀░░░▐████"
        echo"█████▄░░░└┴┴┴┴┴┴┴┘░░░▄█████"
        echo"███████▄░░░░░░░░░░░▄███████"
        echo"██████████▄▄▄▄▄▄▄██████████"
        echo"███████████████████████████"
        echo".....LOADING.....LOADING......CARGANDO"

bueno

RETO 7

# !/bin/bash
# Reto 7
# Menu de opciones que imprime la opción seleccionada
# Author: Juan Antonio Cuahonte Isla - 17/12/21

option=0

actual_processes(){
    echo -e "\nProcesos Actuales:"
    ps -ef
    echo "\n"
    read -n 1 -s -r -p "Presiona ENTER para continuar..."
}

memory_available(){
    echo -e "\nMemoria disponible actualmente"
    free -mth
    echo -e "\n"
    read -n 1 -s -r -p "Presiona ENTER para continuar..."
}

available_disk_space(){
    echo -e "\n"
    df -h
    echo -e "\n"
    read -n 1 -s -r -p "Presiona ENTER para continuar..."
}

network_info(){
    ifconfig -v | cowsay -W 100
    read -n 1 -s -r -p "Presiona ENTER para continuar..."
}

configured_environment_variables(){
    echo -e "\n"
    printenv | cowsay -W 100
    echo -e "\n"
    read -n 1 -s -r -p "Presiona ENTER para continuar..."
}

program_info(){
    echo -e "\nPrograma que te permite conocer
    información importante acerca de tu equipo\n" | cowsay -d
    read -n 1 -s -r -p "Presiona ENTER para continuar..."
}

backup_info(){
    tar -cvf log.tar log.txt
    bzip2 -f log.tar
    zip -e log.zip log.tar.bz2
    usuario=""
    host=""
    echo "A continuación ingresará los datos de envío"
    read -p "Ingresar el host: " host
    read -p "Ingresar el usuario: " usuario
    echo -e "\nEn éste momento se procederá a empaquetar la carpeta y transferirla según los datos ingrasados"

    rsync -avz $(pwd) $usuario@$host:/home/juan
}

while :
do
    # Limpiar la pantalla
    clear
    # Desplegar el menú de opciones
    echo "--------------------------------------------"
    echo "PCUTIL - Programa de utilidad para tu equipo"
    echo "--------------------------------------------"
    echo "               MENU PRINCIPAL               "
    echo "--------------------------------------------"
    echo "1. Procesos Actuales"
    echo "2. Memoria Disponible"
    echo "3. Espacio en Disco"
    echo "4. Información de Red"
    echo "5. Variables de Entorno Configuradas"
    echo "6. Información del Programa"
    echo "7. Backup de información"
    echo "8. Salir"

    # Leer los datos del usuario
    read -n1 -p "Ingrese una opción [1-8]: " option

    # Validar la opción ingresada

    case $option in
        1)
            echo -e "\nMostrar Procesos Actuales....."
            actual_processes
            ;;
        2)
            echo -e "\nMostrar Memoria Disponible....."
            memory_available
            ;;
        3)
            echo -e "\nMostrar Espacio en Disco....."
            available_disk_space
            ;;
        4)
            echo -e "\nInformación de Red....."
            network_info
            ;;
        5)
            echo -e "\nVariables de Entorno Configuradas....."
            configured_environment_variables
            ;;
        6)
            echo -e "\nInformación del Programa....."
            program_info
            ;;
        7)
            echo -e "\nRealizando Backup de información....."
            backup_info
            ;;
        8)
            echo -e "\nSalir del Programa....."
            exit 0
            ;;
        *)
            echo "Elige una opción válida"
            ;;
    esac
done

Listo

! /bin/bash

Reto4

Autor: Jared Jafet Mendizabal

opcion=0

arrOps=(“1- Procesos Actuales” “2- Memoria Disponible” “3- Espacio en Disco” “4- Informacion de Red” “5- Variables de Entorno” “6- Informacion del Programa” “7- Backup Informacion” “8- Salir”)

#Muestra los Procesos Actuales
procesosActuales(){
echo -e "\n${arrOps[0]}"
ps axu
sleep 3
}

#Muestra la Memoria Disponible
memoriaDisponible(){
echo -e "\n${arrOps[1]}"
free
sleep 3
}

#Muestra el Espacio en Disco Restante
espacioDisco(){
echo -e "\n${arrOps[2]}"
df -h
sleep 3
}

#Muestra la Informacion de Red
infoRed(){
echo -e "\n${arrOps[3]}"
ifconfig -a
sleep 3
}

#Muestra las variables de entorno
variablesEntorno(){
echo -e "\n${arrOps[4]}"
env -u VAR
sleep 3
}

#Muestra la informacion del programa
infoPrograma(){
echo -e "\n${arrOps[5]}"
dpkg -l | more
sleep 3
}

#Realiza la transferencia de respaldos
transferenciaBackup(){
fechaBack=$(date +"%F")
nomBack=backupScripts$fechaBack.zip

echo -e "\n${arrOps[6]}"
echo -e "\nArmando Respaldo..."
zip -e $nomBack *.sh

read -p "Ingrese la ip donde se guardara el respaldo: " iphost
read -p "Ingrese el usuario del host donde se hara el respaldo: " user
read -p "Ingrese la ruta donde se guardara el respaldo: " ruta

rsync -avz $nomBack [email protected]$iphost:$ruta

sleep 3

}

while :
do
#Limpiar la pantalla
clear
#Desplegar menu
echo "-----------------------------------------"
echo " MENU PRINCIPAL"
echo "-----------------------------------------"
for ((i=0;i<${#arrOps[*]};i++))
do
echo "${arrOps[$i]}"
done

#Leer los datos del usuario
read -n1 -p "Ingrese una opcion: " opcion

#Validar la opcion
case $opcion in
    1)
        procesosActuales
        ;;
    2)
        memoriaDisponible
        ;;
    3)
        espacioDisco
        ;;
    4)
        infoRed
        ;;
    5)
        variablesEntorno
        ;;
    6)
        infoProframa
        ;;
    7)
        transferenciaBackup
        ;;
    8)
        echo -e "\n${arrOps[7]}"
        exit 0
        ;;
esac

done

<# ! /bin/bash
# programa paea ejemplificar funciones con argumentos 
# autor: Oscar Vargas IG :EcoGeekco

backupDir="$(pwd)/reto7"
option=""
datelog="`date +%Y%m%d%H%M`.log  "

mkdir $backupDir

#Funcion para instalar postgres
instalar_postgres () {
    echo -e "\n Verificar instalación postgres"
    verifyInstall=$(which psql)
    if [ $? -eq 0 ]; then
        echo -e "\n Postgres se encuentra instalado en el equipo"
        else
            read -s -p " ingresar contraseña de sudo:" psswd
            read -s -p " ingresar contraseña para postgres " pwpg
            echo "$psswd" | sudo -S apt update
            echo "$psswd" | sudo -S apt-get -y install postgresql postgresql-contrib
            sudo -u postgres psql -c "Alter user postgres with password '{$pwpg }';"
            echo "$psswd" | sudo -S systemctl enable postgresql.service
            echo "$psswd" | sudo -S systemctl start postgresql.service
     fi
     read -n 1 -s -r -p "Presione [ENTER] para continuar..."

 }

#Funcion para desinstalar postgres
desinstalar_postgres () {
    read -s -p "Ingresar contraseña de sudo:" $psswd
    echo -e "\n"
    echo "$psswd" | sudo -S systemctl stop postgresql.service
    echo "$psswd" | sudo -S apt-get -y --purge remove postgresql\*
    echo "$psswd" | sudo -S rm -r /etc/postgresql
    echo "$psswd" | sudo -S rm -r /etc/postgresql-common
    echo "$psswd" | sudo -S rm -r /var/lib/postgresql
    echo "$psswd" | sudo -S userdel -r postgres
    echo "$psswd" | sudo -S groupel postgresql
    read -n 1 -s -r -p "Presione [ENTER] para continuar..."
}

#Funcion para mirar procesos actuales 
procesos_actuales () {
    ps aux
    ps aux >> $backupDir/$option_$datelog
    ls  $backupDir  *.log
    }

#Funcion para mirar procesos actuales 
memoria_disponible () {
    free -h
    free -h >> $backupDir/$option_$datelog
    ls  $backupDir  *.log
    }

#Funcion para mirar procesos actuales 
disco_disponible () {
    df -h
    df -h >> $backupDir/$option_$datelog
    ls  $backupDir  *.log
    }


#Funcion para mirar procesos actuales 
procesos_red () {
    netstat -tulpn
    netstat -tulpn >> $backupDir/$option_$datelog
    ls  $backupDir  *.log
    }

#Funcion para mirar procesos actuales 
empaquetar_salvar () {
   date=$(date '+%Y%m%d%H%M%S')
    touch $date.log
    cat *.sh  >> $backupDir/$option_$datelog
    sleep 1
    cat /var/log/syslog >> $backupDir/$option_$datelog
    sleep 1
    cat /etc/passwd >> $backupDir/$option_$datelog
    sleep 1
    cd $backupDir
    tar -cvf respaldo.tar *.log
    gzip respaldo.tar
    zip -e respaldo *.tar.gz
    host=""
    usuario=""
    read -p "ingresarel usuario del servidor a transferir el backup" usuario
    read -p "ingresar ip del servidor a respaldar el host" host
    echo -e "\nEn este momento empezaremos transferir los archivos al servidor de respaldo"
    rsync -avz respaldo.zip $usuario@$host:/home/oscar
    cd ..
     echo "done"


    }

while : 
do
   # Limpiar pantalla
   clear
   #Desplegar menu de opciones
   echo "___________________________________________"
   echo "PG UTIL - Programa de utilidad de SysOps "
   echo "___________________________________________"
   echo "           MENU PRINCIPAL                  "
   echo "___________________________________________"
   echo "1. Procesos Actuales "
   echo "2. Memoria disponible "
   echo "3. Espacio en Disco"
   echo "4. Informacion Red "
   echo "5. Instalar Postgresql"
   echo "6. Desinstalar Postgresql "
   echo "7. Backup de todos los logs anteriores"
   echo "8. Salir"

   # leer los datos del usuario 
   read -n1 -p "Ingrese una opción [1-5]" opcion

  # validar la opcion de ingresada 
  case $opcion in
  1)
     echo -e  "\n Procesos Actuales."
     procesos_actuales
     sleep 5
     ;;
  2)
     echo -e "\n Memoria Disponible."
     memoria_disponible
     sleep 5
     ;;
  3)
     echo -e "\n Espacio en disco....."
     disco_disponible
     sleep 5
     ;;
  4)
     echo -e  "\n Informacion Red....."
     procesos_red
     sleep 5
     ;;
  5)
     echo -e  "\n Variables de entorno configuradas....."
     instalar_postgres
     sleep 5
     ;;
  6)
     echo -e "\n Informacion Programa"
     desinstalar_postgres
     sleep 5
     ;;
  7)
     echo -e  "\n Comprimir archivos"
  empaquetar_salvar
     sleep 5
     ;;
  8)
    echo -e "\n Saliendo Muchas Gracias "
    exit 0
    ;;
  esac
done

>

<code>
#!/bin/bash

#Crear un menu con las siguientes opciones:
#   1.Procesos actuales
#   2.Memorias Disponible
#   3.Espacio de Disco
#   4.Informacion de Red
#   5.Variables de entorno congirudadas
#   6.Informacion del Programa
#   7.Backup informacion
#   8.Ingrese una Opcion

opcion=0
tem=""
fecha=$(date +%Y%m%d)

mostrarproc(){
echo -e "\nMostrar Procesos"
ps -au
ps -au >> temp
}

memo(){
echo -e "\nMemoria Disponible"
free -h
free -h >> temp
}

espacio(){
echo -e "\nEspacio en disco"
dfc -T
dfc -T >> temp
}

infored(){
echo -e "\nInformacion de red"
ip a
ip a >> temp
}

vaentorno(){
echo -e "\nVariables de Entorno"
printenv
printenv >> temp
}

infosoft(){
echo -e "\n Version 1.0 de utilidades basicas Copyright ChichoCoria"
}

backuplog(){
echo -e "\nBackup Informacion....."
echo -e "\Creando Archivo.log"
sudo mv temp log$fecha.log
echo -e "\Comprimir archivos .log con clave"
sudo zip -e backuplog.zip *.log
}

salir(){
echo -e "\nSalir del programa"
exit 0
}

while :
do
    clear
    echo "-----------------------------"
    echo "Programa de utilidades EVA1.0"
    echo "-----------------------------"
    echo "        MENU PRINCIPAL       "
    echo "-----------------------------"
    echo "1.Procesos actuales"
    echo "2.Memorias Disponible"
    echo "3.Espacio de Disco"
    echo "4.Informacion de Red"
    echo "5.Variables de entorno congirudadas"
    echo "6.Informacion del Programa"
    echo "7.Backup informacion"
    echo "8.Salir"

    read -n1 -p "Ingrese una Opcion [1-8]:" opcion

    case $opcion in
        1) mostrarproc
           sleep 5
        ;;
        2) memo
           sleep 5
        ;;
        3) espacio
           sleep 5
        ;;
        4) infored
           sleep 5
        ;;
        5) vaentorno
           sleep 5
        ;;
        6) infosoft
           sleep 5
        ;;
        7) backuplog
           sleep 5
        ;;
        8) salir
        ;;
    esac
done

#!/bin/bash
user=“ubuntu"
server=“192.168.0.1"
path=”/home/ubuntu"
date=date +%Y%m%d%H%M%S
opcion=”"
log=“log-$date.log”

funcionps(){
echo "mostrando procesos del sistema"
ps aux > ps-$log && cat $PWD/*$log
}

funcionmem(){
echo "mostrando memoria libre del sistema"
free > mem-$log && cat $PWD/*$log
}

funciondisk(){
echo "mostrando disco del sistema"
df -h > disk-$log && cat $PWD/*$log
}

funcionnet(){
echo "mostrando redes del sistema"
ip a > net-$log && cat $PWD/*$log
}

funcionenv(){
echo "mostrando enviroments del sistema"
env > env-$log && cat $PWD/*$log
}

funcionwhere(){
echo "mostrando informacion de un programa del sistema"
read -p "Indique un programa: " pg
echo ""
whereis $pg > pg-$log && cat $PWD/$log
}
funcionbk(){
echo "realizando backup de logs"
zip -e backup-$date.zip $PWD/.log > back-$log && cat $PWD/*$log
}

funcionscp(){
scp backup-$date.zip [email protected]$server:$path
}

echo "1)Procesos Actuales"
echo "2)Memoria Disponible"
echo "3)Espacio en Disco"
echo "4)Información de Red"
echo "5)Variables de Entorno Configuradas"
echo "6)Información Programa"
echo “7)Backup información”

read -n1 -p “Ingrese una opción:” opcion
echo “”

case $opcion in
1) funcionps ;;
2) funcionmem ;;
3) funciondisk ;;
4) funcionnet ;;
5) funcionenv ;;
6) funcionwhere ;;
7) funcionbk
funcionscp
;;
*)
echo “opcion no valida”
;;
esac

Listo

#!/bin/bash


mostrarProcesos(){
        echo -e "\nProcesos actuales: "
        ps auxf
}

memoriaDisponible(){
        echo -e "\nMemoria disponible: "
        df -h / | cut -d " " -f 10 | tail -1
}

espacioDisco(){
        echo -e "\nEspacio usado en disco: "
         df -h / | cut -d " " -f 12 | tail -1

}

infoRed(){
        echo -e "\nInformación de red: "
        ifconfig
}

variablesEntorno(){
        echo -e "\nVariables de entorno: "
        tail -5 /etc/profile
}

infoPrograma(){
         echo -e "\nInformación del programa:"
         echo "Programa realizado por Alejandro Morales Marcos"
         echo "para completar el reto 4 del"
         echo "curso de programación en shell"
         echo "de la carrera de Fundamentos de Programación"
         echo "de Platzi, a fecha 08-06-2020"
}

hacerBackup(){
        echo -e "\nHaciendo backup... "
        cp reto3.sh reto3.bak
}

clear
while :
do

        echo "00000000000000000000000000000000000000000000"
        echo "0   PELUTILITY - Programa de utilidades    0"
        echo "00000000000000000000000000000000000000000000"
        echo "0        Menú principal - Opciones         0"
        echo "00000000000000000000000000000000000000000000"
        echo "0                                          0"
        echo "0          1. Procesos actuales            0"
        echo "0         2. Memoria disponible            0"
        echo "0       3. Espacio usado en disco          0"
        echo "0         4. Información de red            0"
        echo "0  5. Variables de entorno configuradas    0"
        echo "0        6. Información programa           0"
        echo "0            7. Hacer Backup               0"
        echo "0                8. Salir                  0"
        echo "0                                          0"
        echo "00000000000000000000000000000000000000000000"

        read -n1 -p "Ingrese una opción: " opcion

        case $opcion in

        1)
                mostrarProcesos
                echo -e "\nPresione cualquier tecla para continuar... "
                read
        ;;

        2)
                memoriaDisponible
                echo -e "\nPresione cualquier tecla para continuar... "
                read
        ;;

        3)
                espacioDisco
                echo -e "\nPresione cualquier tecla para continuar... "
                read
        ;;

        4)      infoRed
                echo -e "\nPresione cualquier tecla para continuar... "
                read
        ;;

        5)      variablesEntorno
                echo -e "\nPresione cualquier tecla para continuar... "
                read
        ;;

        6)      infoPrograma
                echo -e "\nPresione cualquier tecla para continuar... "
                read
        ;;

        7)      hacerBackup
                echo -e "\nPresione cualquier tecla para continuar... "
                read

        ;;

        8)      echo -e "\nHasta la vista!!"
                exit 0
        ;;

        esac
done
``

# !/bin/bash
# Programa que muestra algunas funcionalidades basicas del sistema

option=0
usuario=$(logname)
fechaArchivo=$(date +"%F")
fechaAcceso=$(date +"%Y-%m-%d %H:%M:%S")
archivoPath=~/Backup
archivoName=log-$fechaArchivo.log

if [ -d $archivoPath ]; then
    if [ -f $archivoPath/$archivoName ]; then
        echo -e "\nAccedió el usuario: $usuario el día: $fechaAcceso" >> $archivoPath/$archivoName
    else
        touch $archivoPath/$archivoName
        echo -e "\nAccedió el usuario: $usuario el día: $fechaAcceso" >> $archivoPath/$archivoName
    echo -e "\n  Operaciones realizadas:\n" >> $archivoPath/$archivoName
    fi
else
    mkdir $archivoPath
    touch $archivoPath/$archivoName
    echo -e "\nAccedió el usuario: $usuario el día: $fechaAcceso" >> $archivoPath/$archivoName
    echo -e "\n  Operaciones realizadas:\n" >> $archivoPath/$archivoName
fi

function_ProcActual ()
{
    echo -e "\n\tProcesos Actuales\n"
    echo -e "\n\tProcesos Actuales\n" >> $archivoPath/$archivoName
    ps aux
    ps aux >> $archivoPath/$archivoName
    echo -e "\n"
    read -n1 -p "Presione una tecla para continuar..."
}

function_MemDis ()
{
    echo -e "\n\tMemoria Disponible\n" 
    echo -e "\n\tMemoria Disponible\n" >> $archivoPath/$archivoName
    free -h
    free -h >> $archivoPath/$archivoName
    echo -e "\n"
    read -n1 -p "Presione una tecla para continuar..."
}

function_EspDisc ()
{
    echo -e "\n\tMemoria en disco\n" 
    echo -e "\n\tMemoria en disco\n" >> $archivoPath/$archivoName
    du -h
    du -h >> $archivoPath/$archivoName
    echo -e "\n"
    read -n1 -p "Presione una tecla para continuar..."
}

function_InfoRed ()
{
    echo -e "\n\tInformación de Red\n" 
    echo -e "\n\tInformación de Red\n" >> $archivoPath/$archivoName
    ifconfig
    ifconfig >> $archivoPath/$archivoName
    echo -e "\n"
    read -n1 -p "Presione una tecla para continuar..."
}

function_VarEnt ()
{
    echo -e "\n\tVariables de entorno configuradas\n"
    echo -e "\n\tVariables de entorno configuradas\n" >> $archivoPath/$archivoName
    printenv
    printenv >> $archivoPath/$archivoName
    echo -e "\n"
    read -n1 -p "Presione una tecla para continuar..."
}

function_InfoProm ()
{
    echo -e "\n\tInformación del Sistema\n"
    echo -e "\n\tInformación del Sistema\n" >> $archivoPath/$archivoName
    echo -e "\tPrograma que realiza funcionalidades basicas del OS"
    echo -e "\tAutor: Adan Galicia"
    echo -e "\tInformacón de contacto: [email protected]"
    echo -e "\n"
    read -n1 -p "Presione una tecla para continuar..."
}

function_BackupInfo ()
{
    echo -e "\n\tBackup Información\n"
    echo -e "\n\tRealizacion de Backup\n" >> $archivoPath/$archivoName
    read -p "Ingrese el host: " host
    read -p "Ingrese el usuario: " user
    read -p "Ingrese la ruta en donde quiera hacer el backup: " ruta
    
    zip -e backup-$fechaArchivo.zip $archivoPath/*.log
    rsync -avz backup-$fechaArchivo.zip $user@$host:$ruta
}
#Impresion del menú
while :
do
    clear
    echo "------------------------------------------------"
    echo "-------------- Menú Principal ------------------"
    echo "------------------------------------------------"
    echo "-    1.- Procesos Actuales                     -"
    echo "-    2.- Memoria Disponible                    -"
    echo "-    3.- Espacio en Disco                      -"
    echo "-    4.- Información de Red                    -"
    echo "-    5.- Variables de entorno Configuradas     -"
    echo "-    6.- Información del Programa              -"
    echo "-    7.- Backup Información                    -"
    echo "-    8.- Salir                                 -"
    echo "------------------------------------------------"
    
    read -n1 -p "Ingrese la opción deseada [1-8]:  " option

    case $option in
    1) clear
        function_ProcActual 
        ;;
    2) clear
        function_MemDis 
        ;;
    3) clear
        function_EspDisc 
        ;;
    4) clear
        function_InfoRed 
        ;;
    5) clear
        function_VarEnt 
        ;;
    6) clear
        function_InfoProm 
        ;;
    7) clear
        function_BackupInfo
        ;;
    8) clear
        echo -e "\n\tAdios!\n"
        exit
        ;;
    *) clear
        echo -e "\n\tOpción no encontrada\n"
        read -n1 -p "Presione una tecla para continuar..."
        ;;
    esac
done

Listo

#!/bin/bash
# Challenge #7: Utility Host program

option=0
backupDir="$(pwd)/utilityLogs"
logFileSufix="`date +%Y%m%d%H%M%S`.log"

mkdir $backupDir

currentProcesses(){
    echo -e "\nCurrent Processes....."
    processesLogFilename="$backupDir/processes-$logFileSufix"
    ps aux >> $processesLogFilename
    cat $processesLogFilename
    read -n 1 -s -r -p "Presiones [ENTER] para continuar..."
}

availableMemory(){
    echo -e "\nAvailable Memory...."
    availableMemoryLogFilename="$backupDir/memory-$logFileSufix"
    free -m >> $availableMemoryLogFilename
    cat $availableMemoryLogFilename
    read -n 1 -s -r -p "Presiones [ENTER] para continuar..."
}

diskSpace(){
    echo -e "\nDisk Space..."
    diskLogFilename="$backupDir/disk-$logFileSufix"
    df -h >> $diskLogFilename
    cat $diskLogFilename
    read -n 1 -s -r -p "Presiones [ENTER] para continuar..."
}

networkInfo(){
    echo -e "\nNetwork Information..."
    networkLogFilename="$backupDir/network-$logFileSufix"
    ifconfig >> $networkLogFilename
    cat $networkLogFilename
    read -n 1 -s -r -p "Presiones [ENTER] para continuar..."
}

configuredEnvVars(){
    echo -e "\nConfigured Environment Variables..."
    envVarsLogFilename="$backupDir/envVars-$logFileSufix"
    printenv >> $envVarsLogFilename
    cat $envVarsLogFilename
    read -n 1 -s -r -p "Presiones [ENTER] para continuar..."
}

programInfo(){
    echo -e "\nProgram Information..."
    echo -e "Utility program to get info about:" 
    echo "1. Current running processes"
    echo "2. Available memory in system"
    echo "3. Disk usage"
    echo "4. Networking information"
    echo "5. Current configured environment variables"
    echo "6. Print this information"
    echo "7. Backup of the generated info in each option"
    echo "All options store log files data on the following dir: $backupDir"
    echo "Backup option compress the logs dir in one single file."
    read -n 1 -s -r -p "Presiones [ENTER] para continuar..."
}

backupInfo(){
    echo -e "\nBackup Information..."
    tar -cvf backupInfo.tar $backupDir/*.log
    gzip backupInfo.tar
    if [ $? -eq 0 ]; then
        echo "Backup successfully generated..."
    else
        echo "Error creating backup file"
    fi
    read -n 1 -s -r -p "Presiones [ENTER] para continuar..."
}

while :
do
    #Clearing screen
    clear
    #Printing the menu
    echo "______________________________________"
    echo "Challenge 4 - Printing an Options Menu"
    echo "______________________________________"
    echo "               MAIN MENU              "
    echo "______________________________________"
    echo "1. Current Processes"
    echo "2. Available Memory"
    echo "3. Disk space"
    echo "4. Network Information"
    echo "5. Configured Environment Variables"
    echo "6. Program Information"
    echo "7. Backup information"
    echo "8. Exit"

    # Capturing user information
    read -n1 -p "Please enter an option [1-8]:" option

    #Checking the entered option
    case $option in
        1) currentProcesses;;
        2) availableMemory;;
        3) diskSpace;;
        4) networkInfo;;
        5) configuredEnvVars;;
        6) programInfo;;
        7) backupInfo;;
        8)
            echo -e "\nExit Program\n"
            exit 0
            ;;
    esac
done

Aquí mi código.

# !/bin/bash
# Reto 7: Modificar nuestro programa utilityHost.sh para crear cinco funciones de acuerdo
# al menú creado anteriormente y completarlo con lo visto en clase.
# Autor: Erick Jiménez - @erjimrio

opcion=0
fecha=`date +"%Y%m%d"`
momento=`date +"%Y%m%d %H:%M:%S"`
usuario=`whoami`
repo=~/shellCourse/backup
host=""
usuarioHost=""

# Función para conocer los procesos en ejecución
procesos () {
    echo -e "\nProcesos actuales"
    ps -ely | less
    read -n 1 -s -r -p "Presione [ENTER] para continuar..."
}

# Función para conocer la memoria disponible

memoria () {
    echo -e "\nMemoria disponible"
    free -h
    read -n 1 -s -r -p "Presione [ENTER] para continuar..."
}

# Función para conocer el espacio en disco
espacio () {
    echo -e "\nEspacio en disco"
    df -h
    read -n 1 -s -r -p "Presione [ENTER] para continuar..."
}

# Función para conocer la información de red

infoRed () {
    echo -e "\nInfo de red"
    ifconfig | less
    read -n 1 -s -r -p "Presione [ENTER] para continuar..."
}

# Función para conocer las variables de entorno configuradas

variablesEntorno () {
    echo -e "\nVariables de entorno configuradas"
    printenv | less
    read -n 1 -s -r -p "Presione [ENTER] para continuar..."
}

# Función para conocer información del sistema operativo
infoSistema () {
    echo -e "\nInformación programa"
    uname -ap
    read -n 1 -s -r -p "Presione [ENTER] para continuar..."
}

# Verifica si existe el archivo log en el repositorio

if [ -d $repo ]; then   # Existe el repositorio
    if [ -f $repo/log$fecha.log ]; then     # Existe el archivo log
        echo "$usuario|$momento|Ingresó" >> $repo/log$fecha.log
    else    # No existe el archivo log
        touch $repo/log$fecha.log
        echo "Usuario|Fecha y hora [yyyymmdd hh:mm:ss]|Acción" >> $repo/log$fecha.log
        echo "$usuario|$momento|Ingresó" >> $repo/log$fecha.log
    fi
else    # No existe el repositorio
    mkdir $repo
    touch $repo/log$fecha.log
    echo "Usuario|Fecha y hora [yyyymmdd hh:mm:ss]|Acción" >> $repo/log$fecha.log
    echo "$usuario|$momento|Ingresó" >> $repo/log$fecha.log
fi

# Muestra el menú
while :
do 
    # Limpiar la pantalla
    clear
    # Desplegar el menú de opciones
    echo "-------------------------------------------------------------------------------------------"
    echo "                                            Reto 7                                         "
    echo "-------------------------------------------------------------------------------------------"
    echo "                                        MENÚ PRINCIPAL                                     "
    echo "-------------------------------------------------------------------------------------------"
    echo -e "\t 1. Procesos actuales"
    echo -e "\t 2. Memoria disponible"
    echo -e "\t 3. Espacio en disco"
    echo -e "\t 4. Información de red"
    echo -e "\t 5. Variables de entorno configuradas"
    echo -e "\t 6. Información programa"
    echo -e "\t 7. Backup información"
    echo -e "\t 8. Salir\n"

    # Leer los datos del usuario - capturar información
    read -n1 -p "Ingrese una opción [1-8]" opcion

    # Validar la opción ingresada
    case $opcion in 
        1)
            echo "$usuario|$momento|Seleccionó: Procesos actuales" >> $repo/log$fecha.log
            procesos
            ;;
        2)
            echo "$usuario|$momento|Seleccionó: Memoria disponible" >> $repo/log$fecha.log
            memoria
            ;;
        3)
            echo "$usuario|$momento|Seleccionó: Espacio en disco" >> $repo/log$fecha.log
            espacio
            ;;
        4)
            echo "$usuario|$momento|Seleccionó: Información de red" >> $repo/log$fecha.log
            infoRed
            ;;
        5)
            echo "$usuario|$momento|Seleccionó: Variables de entorno configuradas" >> $repo/log$fecha.log
            variablesEntorno
            ;;
        6)
            echo "$usuario|$momento|Seleccionó: Información del programa" >> $repo/log$fecha.log
            infoSistema
            ;;
        7)
            echo -e "\nBackup información"
            echo "$usuario|$momento|Seleccionó: Backup información" >> $repo/log$fecha.log
            echo -e "\nRealizando respaldo"
            echo "$usuario|$momento|Realizando respaldo" >> $repo/log$fecha.log
            echo -e "\nEmpaquetando todos los archivos .log de la carpeta repo"
            # Comprimimos los archivos .log y protegemos con contraseña
            zip -e backup$fecha.zip $repo/*.log
            # Enviamos respaldo a repositorio remoto
            read -p "Ingrese dirección IP del Host: " host
            read -p "Ingrese el usuario en el Host: " usuarioHost

            rsync -avz backup$fecha.zip $usuarioHost@host:/home/aprendiz/Documentos/Curso_Bash
            sleep 3
            ;;
        8)
            echo -e "\nSalir del programa"
            echo "$usuario|$momento|Salió del programa" >> $repo/log$fecha.log
            exit 0
            ;;
    esac 
done 

Me quedan algunas dudas sobre los permisos, me marcan permisos denegados, pero si realiza las tareas.
le dejo mi código y una imagen de mi comentario

#!/bin/bash
#Programa que permite manejar las utilidades de Postgres con funciones 
#Autor: jdavilar  [email protected]

op=0
fechahoy=`date +%Y%m%d`

#Esta es la funcion para instalar posgres
instalar_postgres () {
     echo -e "\nVerificar instalacion de Postgres"
     #el comando which verifica si esta presente un programa
     #las palabras reservadas psql son para postgres
     #el valor que resultara sera verdadero o falso
     verificarInstalacion=$(which psql)
     if [ $? -eq 0 ]; then
     echo -e "\nPostgres ya esta instalado en el equipo"
     else
     #solicitamos de manera silenciosa el pasword
        read -s -p "Ingrese el password" pas
        read -s -p "Ingrese el password a utilizar en Postgres" pasPostgres
      #ahora mandamos por medio echo los parametros al usuario sudo
      #con el idtificador -S le decimos que espere un comando especifico y el prametro -y es para que instale sin preguntar
        echo "$pas" | sudo -S apt update
        echo "$pas" | sudo -S apt-get -y install postgresql postgresql-contrib
        #creamos el usuario y su pasword en postgres
        sudo -u postregs psql -c "ALTER USER postgres WITH PASSWORD '{pasPostgres}';"
        echo "$pas" | sudo -S systemctl enable postgresql.service
        echo "$pas" | sudo -S systemctl start postgresql.service
     fi
    #parametro "n" mantener el cursos en la misma linea "r" para el esperar un enter
    read -n 1 -s -r -p "Presione [Enter] para continuar....."
}

#Esta es la funcion es para desinstalar postgres 
desinstalar_potsgres () {
     verificarInstalacion=$(which psql)
     if [ $? -eq 1 ]; then
        echo -e "\nPostgres no esta instalado en el equipo"
     else
        echo -e "\n"
        read -s -p "Ingrese el password" pas
        #paramos el servicio
        echo "$pas" | sudo -S systemctl stop postgresql.service
        #removemos todo lo que se refiera a postgres[ "-y" es para que no pregunte, --purge remove todo]
        echo "$pas" | sudo -S apt-get -y --purge remove postgresql\*
        #Borraremos todos los directorios
        echo "$pas" | sudo -S rm -r  /etc/postgresql
        echo "$pas" | sudo -S rm -r  /etc/postgresql.common
        echo "$pas" | sudo -S rm -r  /var/lib/postgresql
        #Borramos usuario y grupo de postgres
        echo "$pas" | sudo -S userdel -r postgres
        echo "$pas" | sudo -S groupdel PostgreSQL
    fi
    read -n 1 -s -r -p "Presione [Enter] para continuar....."
}
#Esta es la funcion hacer respaldo de postgres
respaldo_postgres () {
    verificarInstalaccion=$(which psql)
    if [ $? -eq 0 ]; then
        echo "Lista de las bases de datos"
        sudo -u postgres psql -c "\l"
        read -p "Elegir la base de datos a respaldar:" BdD
        echo -e "\n"
        #validamos con -d si el direcrorio que se manda como parametro existe
        if [ -d "$1" ]; then
            echo "Establecemo los permiso al directorio"
            echo "$pas" | sudo -S chmod 755 $1
            echo "Realizando el respaldo"
            #con esta linea hacemos el respadlo con el argumento -F File y c del contexto
            sudo -u postgres pg_dump -Fc $BdD > "$1/BdDRespaldo$fechahoy.bak"
            echo "Respaldo realizado en :$1BdDRespaldo$fechahoy.bak"
        else
                echo "El directorio $1 no existe"
        fi
    else
        echo "No esta instaldo Postgres en su sistema"
    fi
    read -n 1 -s -r -p "Presione [Enter] para continuar....."
}

#Esta es la funcion restaurar respaldo
restaurar_respaldo_postgres () {
    echo "Para listar los respaldos actuales"
    ls -1 $1/*.bak
    read -p "Teclea el respaldo a restaurar" restaura
    echo -e "\n"
    read -p "Ingrese el nombre de la base de datos destino" BdDdestino
#Verificar que la base de datos existe
    verificar=$(sudo -u postgres psql -lqt | cut-d \| -f 1 | grep -wq $BdDdestino)
    if [ $? -eq 0 ]; then
        echo "restaurando en la base de datos destino: $BdDdestino"
    else
        #si no existe la basse de datos se crea
        sudo  -u postgres psql -c "create database $BdDdestino"
    fi
#Verificamos si el archivo a restaurar existe
    if [ -f "$1/$restaura" ]; then
        echo "Restaurando respaldo...."
        #inicia la restauracion
        sudo -u postgres pg_restore -Fc -d $BdDdestino "$rutaBk/$restaura"
        echo "La base de datos a restaurar es $restaura en el destino $BdDdestino"
        #Listamos todas las base de datos 
        sudo -u postgres psql -c "\l"
    else
        echo "No se econtro el respaldo $restaura"
   fi
   read -n 1 -s -r -p "Presione [Enter] para continuar....."
}

while :
do
   #limpiar pantalla
   clear
   #desplegar el menú de opciones
   echo "--------------------------------"
   echo "        jdavila                 "
   echo "--------------------------------"
   echo "Programa de utilidad de Postfres"
   echo "________________________________"
   echo "      Menú principal            "
   echo "________________________________"
   echo "1.- Instalar Postgres"
   echo "2.- Desinstalar postgres"
   echo "3.- Obten un respaldo"
   echo "4.- Restaurar un respaldo"
   echo "5.- Salir"
   #Leer los datos del usuario
   read -n1 -p "Ingrese una opcion:(1-5)" op
   #validar la opcion ingresada
   case $op in
     1)
        instalar_postgres
        sleep 3
        ;;
     2)
       desinstalar_potsgres
        sleep 3
        ;;
     3)
        read -p "Mencione el directorio Backup:" directorioBackup
        respaldo_postgres $directorioBackup
        sleep 3
        ;;
     4)
        read -p "Mencione el directorio respaldos:" directoriorespaldos
        restaurar_respaldo_postgres $directoriorespaldos
        sleep 2
        ;;
     5)
        echo -e "\nAdios.."
        break
        exit 0
        ;;
     *) echo -e "\nOpción no valida"
     sleep 1
   esac
done

![](