Curso de Programaci贸n en Bash Shell

Curso de Programaci贸n en Bash Shell

Marco Antonio Toscano Freire

Marco Antonio Toscano Freire

Reto 7

42/43

Lectura

Reto 7:

Modificar nuestro programa utiliyHost.sh para crear cinco funciones de acuerdo al men煤 creado anteriormente y completarlo con lo visto en clases.

Aportes 17

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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=鈥渦buntu"
server=鈥192.168.0.1"
path=鈥/home/ubuntu"
date=date +%Y%m%d%H%M%S
opcion=鈥"
log=鈥渓og-$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 鈥淚ngrese una opci贸n:鈥 opcion
echo 鈥溾

case $opcion in
1) funcionps ;;
2) funcionmem ;;
3) funciondisk ;;
4) funcionnet ;;
5) funcionenv ;;
6) funcionwhere ;;
7) funcionbk
funcionscp
;;
*)
echo 鈥渙pcion 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

![](