Curso de Programaci贸n en Bash Shell

Curso de Programaci贸n en Bash Shell

Marco Antonio Toscano Freire

Marco Antonio Toscano Freire

Reto 6

38/43

Lectura

Reto 6:

Modificar programa utilityHost. sh para empaquetar los logs generados utilizando alg煤n formato de compresi贸n, colocarle una clave y pasarlo a otra m谩quina a trav茅s de SSH, cuando se seleccione la opci贸n 7. Backup de Informaci贸n

Aportes 26

Preguntas 0

Ordenar por:

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

#!/bin/bash
# Programa que empaqueta, comprime, cifra y env铆a informaci贸n a trav茅s de rsync
# Autor: YoJan

option="VariableOption"
result="VariableResult"
fecha=$(date +"%F_%H")
echo "El valor de option: $option" > logOption_$fecha.txt
echo "El valor de result: $result" > logResult_$fecha.txt

# Empaquetar y comprimir los logs generados
echo -e "\nIniciando el empaquetado y compresi贸n con tar y gz....."
tar -czvpf logOption_$fecha.tar.gz logOption_$fecha.txt
tar -czvpf logResult_$fecha.tar.gz logResult_$fecha.txt
sleep 3

# Agregando cifrado con OpenSSL
echo -e "\nAgregando cifrado a logOption_$fecha.tar.gz"
openssl enc -aes-256-cbc -e -in logOption_$fecha.tar.gz -out logOption_$fecha.tar.gz.enc

echo -e "\nAgregando cifrado a logResult_$fecha.tar.gz"
openssl enc -aes-256-cbc -e -in logResult_$fecha.tar.gz -out logResult_$fecha.tar.gz.enc

# Creando carpeta de backup para mover y transferir
echo -e "\nMoviendo los archivos cifrados a una nueva carpeta....."
mkdir -m 755 bk_logs
mv logOption_$fecha.tar.gz.enc bk_logs
mv logResult_$fecha.tar.gz.enc bk_logs
sleep 3

# Pasar a un servidor remoto la carpeta bk_logs utilizando rsync
read -p "Ingrese host: " host
read -p "Ingrese usuario: " user

echo -e "\nTransfiriendo los archivos"
rsync -avz bk_logs $user@$host:/home/luna
# !/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

#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
        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..."
        ;;
    2) clear
        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..."
        ;;
    3) clear
        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..."
        ;;
    4) clear
        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..."
        ;;
    5) clear
        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..."
        ;;
    6) clear
        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..."
        ;;
    7) clear
        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
        ;;
    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
#! /bin/bash
option=''
while :
do
#Limpieza de pantalla
clear
echo "_______________________"
echo "    Menu de opciones   "
echo "_______________________"
echo -e "\n"
echo "1. Instalar Postgres"
echo "2. Desinstalar Postgres"
echo "3. Crear un backup"
echo "4. Restaurar backup"
echo "5. empaquetar y comprimir "
echo "6. Enviar por ssh "
echo "7. Salir"
echo -e "\n"

read -n1 -p "Elija una Opcion :" option
echo -e "\n"


    case $option in
        1)
           echo "Instalando Postgres...."
           if [ -f  ~/logs/instalandoPostgres.log ]; then
              echo "El fichero ya existe...>> Agregando log "
              echo "$(date '+%F %H %M %S')  $(whoami)"  >> ~/logs/instalandoPostgres.log
              sleep 3
           else
              echo "el Fichero no existe > creando fichero "
              echo "$(date '+%F %H %M %S')  $(whoami)" > ~/logs/instalandoPostgres.log
              sleep 3
           fi
           ;;

        2)
           echo "Desinstalando Postgres"
           date '+%F %H %M %S' > ~/logs/DesinstalandoPosgtres.log
           sleep 3
           ;;

        3)
           echo "Crear Backup "
           date '+%F %H %M %S'> ~/logs/SacarRespaldo.log
           sleep 3
           ;;

        4)
           echo "Restaurar Backup "
           date '+%F %H %M %S' > ~/logs/RestaurandoRespaldo.log
           sleep 3
           ;;

        5)
           echo "Empaquetando y comprimiendo todos los logs "
           tar -cvf Logs.tar ~/logs
             if  [ -e Logs.tar ]; then
             echo "Comprimiendo el archivos  .... status OK!"
                gzip -9 Logs.tar
                sleep 3
             else
                echo "No se pudo comprimir... archivo logs.tar no encontrado "
             fi
            ;;

        6)echo "enviando por SSH "
           #rsync -avz $(pwd) [email protected](ip):direccionDestino
           sleep 3
          ;;

        7) echo "Saliendo "
           exit 0
           ;;
    esac
done

Reto 6, Crea x cantidad de archivos *log.txt y los empaqueta y transferie a trav茅s de rsync a mi mobile Android.

Usando SSHelper
rsync

rsync2

#!/bin/bash
#Reto 6 + Empaquetar los logs en un formato de compresi贸n
#       + Colocar una clave
#       + Enviarlo a otra m谩quina a mi cel
#       + Cuando se selecciona la op 7

reps=""

echo "***********Bienvenido al reto 6*******************"

echo "For para crear logs"

read -n1 -p "Ingrese el n煤mero de logs a crear:  " reps

for ((i=1;i<=reps;i++))
do
cat <<EOM> $(date +%T.%3N)log.txt
$(date +%Y%m%d-%H:%M%S)
EOM
echo "******"
echo "**$i**"
echo "******"
sleep 3
done

tar -cvf 6fileLogs.tar *log.txt

zip -e 6fileLogs.tar.zip 6fileLogs.tar

echo -e "\n Se va a pedir la clave de tu Android"

rsync -avh -e 'ssh -p 2222' 6fileLogs.tar [email protected]:/data/data/com.arachnoid.sshelper/home/SDCard/Download

Reto 6

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

option=0

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 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....."
            sleep 3
            ;;
        2)
            echo -e "\nMostrar Memoria Disponible....."
            sleep 3
            ;;
        3)
            echo -e "\nMostrar Espacio en Disco....."
            sleep 3
            ;;
        4)
            echo -e "\nMostrar Informaci贸n de Red....."
            sleep 3
            ;;
        5)
            echo -e "\nMostrar Variables de Entorno Configuradas....."
            sleep 3
            ;;
        6)
            echo -e "\nMostrar Informaci贸n Programa....."
            sleep 3
            ;;
        7)
            echo -e "\nRealizando Backup de informaci贸n....."

            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

            ;;
        8)
            echo -e "\nSalir del Programa....."
            exit 0
            ;;
        *)
            echo "Elige una opci贸n v谩lida"
            ;;
    esac
done

Reto completado, aunque no me convence la estructura 馃槙

#!/bin/bash

echo "Hey!"
read -p "Do you want to send a file? (0/1): " Pick

  if [ $Pick == 0 ]; then
    read -p "Enter the host: " host
      read -p "Enter the user: " user
    echo "...  "; sleep 3
    read -p "Enter the directory name" file
      read -p "Enter destiny: " destiny
    echo   "Delivering..."; sleep 1
      echo ""
    rsync -avz $file $user@$host:$direct
  else
    echo "See you!"
  fi

Agrego solo el fragmento correspondiente a la funcion 7:

  1.     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
        ;;

reto 6

opcion=0

while :
do
	#Limpiar pantalla
	clear
	#desplegar menu de opciones
	echo "_________________________________________"
	echo "UBUNTU - Programa de utilidad del servidor"
	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 Programa"
	echo "7. Backup informaci贸n"
	echo "8. Salir."

	#Leer los datos de usuario
	read -n1 -p "Ingrese una opci贸n [1-8]:" opcion

	#validar la opci贸n ingresada
	case $opcion in
		1) echo -e  "\nProcesos actuales...."
			ps -fea
			sleep 3
			;;
		2) echo -e "\n Memoria disponible..."
			free -m
			sleep 3
			;;
		3) echo -e "\nEspacio en disco..."
			df -h
			sleep 3
			;;
		4) echo -e "\nInformaci贸n de Red ..."
			ip a
			sleep 3
			;;
		5) echo -e "\nVariables de entorno"
			env
			sleep 3
			;;
		6) echo -e "\nInformaci贸n programa"
			dpkg -l |more
			sleep 3
			;;
		7) echo -e "\nBackup informaci贸n"
			tar -czvf backup.tar.gz *
			zip -e backup.tar.gz *.sh
			rsync -avr backup.tar.gz [email protected]:/tmp
			sleep 3
			;;
		8) echo -e "\nSaliendo..."
			exit 0
			;;
	esac
done

Mi Reto va de la siguiente forma:

#!/bin/bash
# Reto 6
# Autor: Jose Suarez

fecha=`date +%Y%m%d%H%M%S`
usuario=$(logname)
archivo=log-`date +%Y%m%d%H%M%S`.log

host=""
user=""

touch $archivo

echo -e "\n"
#Agregar informaci贸n del usuario
echo "Script ejecutado por el usuario: $usuario " >> $archivo
echo -e "\n"
#Agrego la fecha
echo "En la Fecha: $fecha " >> $archivo

#Menu

while :
do
        #Limpiar pantalla
        clear
        echo -e "\n"
        echo "************************************************"
        echo "******************OPCIONES**********************"
        echo "************************************************"
        echo -e "\n"
        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 -e "\n"
        echo "************************************************"

        read -n1 -p "Ingrese una opci贸n (1-8): " option

        clear
        echo -e "\nLa opcion seleccionada fue $option " >> $archivo
        clear

        case $option in

        1)
                clear
                echo -e "\nProcesos Actuales"
                ps -u
                echo -e "\n"
                sleep 6
                ;;

        2)
                clear
                echo -e "\nMemoria Disponible"
                free -h
                echo -e "\n"
                sleep 6
                ;;

        3)
                clear
                echo -e "\nEspacio en disco"
                df -h
                echo -e "\n"
                sleep 3
                ;;

        4)
                clear
                echo -e "\nInformaci贸n de Red"
                netstat -r
                echo -e "\n"
                sleep 3
                ;;

        5)
                clear
                echo -e "\nVariables de Entorno Configuradas"
                echo $PATH
                echo -e "\n"
                sleep 5
                ;;

        6)
                clear
                echo -e "\nInformaci贸n del Programa"
                echo -e "\nDesarrollado por RastComputer"
                echo -e "\nVersion 1.0"
                echo -e "\nA帽o 2020"
                sleep 3
                ;;

        7)
                clear
                echo -e "\nBackup Informaci贸n "
                echo -e "\n Se le solicitara una clave de encriptado del backup de logs\n"
                zip -e backup.zip *.log
                sleep 2
                clear
                read -p "Ingrese el host para la copia remota del backup: " host
                echo -e "\n"
                read -p "Ingrese el nombre del Usuario para coneccion remota: " user
                clear
                echo -e "\n En este momento se proceder谩 a transferir el archivo\n"

                rsync -avz $(pwd) $user@$host:/home/btk

                echo -e "\n"
                sleep 3
                ;;

        8)
                clear
                echo -e "\nHasta la vista baby"
                sleep 3
                clear
                exit 0
                ;;
        esac
done

Aqui esta mi reto#6
Solamente he tomado el mismo codigo que utilice para el reto#5 y agregue la opcion de hacer respaldos donde programo:

  1. Que el sistema cree una archivo .tar con los logs.txt que hay en el directorio
  2. Que el sistema cree un archivo .zip con su clave de seguridad y conteniendo los archivos .tar que se crean en el punto 1
    y
  3. Que el sistema haga una transferencia usando rsync de todos los archivos .zip y los guarde en una carpeta de Backups en el server.
# ! /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`

 #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") 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 --- Instrucciones Consultadas" >> logs_reto6/$NEWFILE

                       sleep 5
            ;;

       "2") echo -e "\nIntroduzca el numero A: "
            read
            numA=$REPLY
            echo -e "Introduzca el numero B: "
            read
            numB=$REPLY
            #read -p "Introduzca el numero A: " numA
            #read -p "Introduzca el numero B: " numB
            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_reto6/$NEWFILE
                    sleep 5
                    ;;

        "3")    echo -e "\n"
                echo "$DATE-$TIME --- Usuario escoge chequear formato de numero telefonico" >> logs_reto6/$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_reto6/$NEWFILE
                                   else

                                 echo "$DATE-$TIME --- Usuario responde NO para cambiar formato de  $telefono" >> logs_reto6/$NEWFILE
                                 echo "Volviendo al Menu Principal..."
                             fi                              fi

                            sleep 5
                        ;;

             "4") echo -e "\n"
                  read -p "Ingrese la ruta de un directorio: " dirPath
                  if [[ -d $dirPath  ]]; then
                      echo "$DATE-$TIME --- Usuario consulta satisfactoriamente el directorio $dirPath" >> logs_reto6/$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_reto6/$NEWFILE
                  fi

                    sleep 5

                  ;;

              "5")echo -e "\n"
                  read -p "Ingrese la ruta del archivo: " filePath
                  if [[ -e $filePath  ]]; then
                        echo "$DATE-$TIME --- Usuario consulta el archivo $filePath" >> logs_reto6/$NEWFILE
                        cat $filePath
                          else
                            echo "No se encuentra el archivo o Nombre de archivo Incorrecto"
                            echo "$DATE-$TIME --- Usuario No encuentra $filePath" >> logs_reto6/$NEWFILE
                  fi
                    sleep 6

                    ;;

              "6")echo -e "\n"
                   read -n1 -p "Desea hacer Backup del Directorio logs_reto6 s/n: " respBackup
                   if [[ $respBackup = "s" ]]; then
                     echo -e  "\ncreando archivo tar..."
                     sleep 2
                     tar -cvf logs_reto6/backup_`date +%Y%m%d`_`date +%H%M%S`.tar logs_reto6/

                     echo -e "\nCreando archivo ZIP..."
                     echo "Debera introducir una Clave de Seguridad..."
                     sleep 2
                     zip -e logs_reto6/zip_`date +%Y%m%d`_`date +%H%M%S`.zip /shellCourse/logs_reto6/*.tar

                     echo "Transfieriendo archivo ZIP..."
                     echo "Clave de Administrador para Transferencias"
                     sleep 2
                     rsync -avz /shellCourse/logs_reto6/*.zip [email protected]:/$HOME/backup_logs_reto6/
                     echo "$DATE-$TIME --- Usuario ejecutando proceso de Respaldo" >> logs_reto6/$NEWFILE
                     sleep 3
                     echo "Backup Realizado con Exito..."
                   else

                     echo "$DATE-$TIME --- Usuario cancela proceso de Respaldo " >> logs_reto6/$NEWFILE
                     echo "Saliendo del modulo de Respaldos..."
                     sleep 3
                   fi
                   ;;

                   "7")    echo -e "\n"
                               echo -e "Saliendo..."
                               echo "$DATE-$TIME --- Usuario sale de la aplicacion" >> logs_reto6/$NEWFILE
                               exit 0
                   
                               ;;
                   
                         *) echo "Opcion Incorrecta, Lo sentimos"
                   
                   
                         esac
                   done```

# ! /bin/bash
# Programa que permite manejar las utilizades de Postres
# Autor: Anthony SQC edited by Jordam

if [[ -d"./logs" ]]; then
    echo"El directorio de logs ya existe, no voy a crear otro"
else
    echo"El directorio de logs no existe, voy a crearlo"
    mkdir -m 755 logs
fi


opcion=0
while :
do
    #Limpiar pantalla
    clear 
    #Imprimir menu
    echo"-----------------------------------------" 
    echo"PGUTIL - Programa de utilidad de Postgres"
    echo"-----------------------------------------" 
    echo"              MEN脷 PRINCIPAL             "
    echo"-----------------------------------------" 
    echo"1. Instalar Postgres"
    echo"2. Desintalar Postgres"
    echo"3. Sacar un registro"
    echo"4. Restar regsitro"
    echo"5. Salir"
    echo"6. Morir谩"
    echo"7. Realizar backup y enviar por SSH"
    
    #Leer los datos del usuario - capturar informaci贸n
    read -n1 -p "Ingrese una opcion [1-7]" opcion

    #Validar la opcion ingresada
    case $opcion in
    1)
        cadena="\nInstalar Postgres.......\n"
        echo -e"$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e"$cadena" >> $logName
        sleep 3;;
    2)
        cadena="\nDesintalar Postgres....\n"
        echo -e"$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e"$cadena" >> $logName
        sleep 3;;
    3)
        cadena="\nSacar un registro.....\n"
        echo -e"$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e"$cadena" >> $logName
        sleep 3;;
    4)
        cadena="\nRestaurar un registro.\n"
        echo -e"$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e"$cadena" >> $logName
        sleep 3;;
    5)
        cadena="Salida del programa\n"
        echo -e"$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e"$cadena" >> $logName
        break;;

    6)
        cadena="Se Procede\n"
        echo -e"$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e "$cadena" >> $logName
        break;;
     7)
        tar -cvf backupEjecutables.tar ./*.sh
        zip -e backupEjecutables.tar.zip backupEjecutables.tar
        rsync -avz backupEjecutables.tar.zip [email protected]:${HOME}/recibosRSYNC
        rm backupEjecutables.tar.zip
        echo"Informacion enviada."
        break
        ;;
    esac
done


Un problema:
En esta clase 鈥淩eto 6鈥 El bot贸n de la siguiente clase se salta a la ultima clase, en vez de ir a la clase 39 馃槮

DONE
nota: el comando donde se envia el archivo comprimido a otro equipo remoto esta comentado porque no tengo otro equipo con linux en mi red con el que pueda hacer la prueba, en su lugar puse un ejemplo general

#! /bin/bash

option=0
ini=0

while :
do    
    if [ $ini == 0 ]; then
        for ((i=0;i<3;i++))
        do
            clear
            echo "鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻堚枅鈻堚杸鈻鈻鈻戔枒鈻戔枒鈻戔枒鈻戔杸鈻鈻鈻堚枅鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔杸鈻堚枅鈻堚枅"
            echo "鈻堚枅鈻堚攤鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔攤鈻堚枅鈻"
            echo "鈻堚枅鈻屸攤鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔攤鈻愨枅鈻"
            echo "鈻堚枅鈻戔敂鈹愨枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈹屸敇鈻戔枅鈻"
            echo "鈻堚枅鈻戔枒鈹斺攼鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔攲鈹樷枒鈻戔枅鈻"
            echo "鈻堚枅鈻戔枒鈹屸敇     鈻戔枒鈻戔枒鈻     鈹斺攼鈻戔枒鈻堚枅"
            echo "鈻堚枅鈻屸枒鈹       鈻戔枒鈻       鈹傗枒鈻愨枅鈻"
            echo "鈻堚枅鈻堚枒鈹      鈻戔枒 鈻戔枒      鈹傗枒鈻堚枅鈻"
            echo "鈻堚枅鈻鈹鈹樷枒鈻戔枒鈻戔枒鈻戔枒   鈻戔枒鈻戔枒鈻戔枒鈻戔敂鈹鈻鈻堚枅"
            echo "鈻堚枅鈻勨枒鈻戔枒    鈻戔枒   鈻戔枒    鈻戔枒鈻戔杽鈻堚枅"
            echo "鈻堚枅鈻堚枅鈻勨攢鈹   鈻戔枒鈻戔枒鈻戔枒鈻   鈹斺攢鈻勨枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻堚枒鈻  鈹鈹敩鈹敩鈹敩鈹攢  鈻戔枒鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻屸枒鈻戔枒 鈹敿鈹尖敿鈹尖敿鈹尖敿  鈻戔枒鈻戔枑鈻堚枅鈻堚枅"
            echo "鈻堚枅鈻堚枅鈻堚杽鈻戔枒鈻戔敂鈹粹敶鈹粹敶鈹粹敶鈹粹敇鈻戔枒鈻戔杽鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻堚枅鈻堚杽鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔杽鈻堚枅鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻勨杽鈻勨杽鈻勨杽鈻勨枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻"
            echo "LOADING...LOADING...LOADING"
            sleep 0.3
            clear
            echo "鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻堚枅鈻堚杸鈻鈻鈻戔枒鈻戔枒鈻戔枒鈻戔杸鈻鈻鈻堚枅鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔杸鈻堚枅鈻堚枅"
            echo "鈻堚枅鈻堚攤鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔攤鈻堚枅鈻"
            echo "鈻堚枅鈻屸攤鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔攤鈻愨枅鈻"
            echo "鈻堚枅鈻戔敂鈹愨枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈹屸敇鈻戔枅鈻"
            echo "鈻堚枅鈻戔枒鈹斺攼鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔攲鈹樷枒鈻戔枅鈻"
            echo "鈻堚枅鈻戔枒鈹屸敇鈻勨杽鈻勨杽鈻勨枒鈻戔枒鈻戔枒鈻勨杽鈻勨杽鈻勨敂鈹愨枒鈻戔枅鈻"
            echo "鈻堚枅鈻屸枒鈹傗枅鈻堚枅鈻堚枅鈻堚枌鈻戔枒鈻戔枑鈻堚枅鈻堚枅鈻堚枅鈹傗枒鈻愨枅鈻"
            echo "鈻堚枅鈻堚枒鈹傗枑鈻堚枅鈻堚杸鈻鈻戔枒鈻勨枒鈻戔杸鈻鈻堚枅鈻堚枌鈹傗枒鈻堚枅鈻"
            echo "鈻堚枅鈻鈹鈹樷枒鈻戔枒鈻戔枒鈻戔枒鈻愨枅鈻屸枒鈻戔枒鈻戔枒鈻戔枒鈹斺攢鈻鈻堚枅"
            echo "鈻堚枅鈻勨枒鈻戔枒鈻勨杽鈻勨枔鈻戔枒鈻鈻堚杸鈻戔枒鈻撯杽鈻勨杽鈻戔枒鈻戔杽鈻堚枅"
            echo "鈻堚枅鈻堚枅鈻勨攢鈹樷枅鈻堚枌鈻戔枒鈻戔枒鈻戔枒鈻戔枑鈻堚枅鈹斺攢鈻勨枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻堚枒鈻戔枑鈻堚攢鈹敩鈹敩鈹敩鈹攢鈻堚枌鈻戔枒鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻屸枒鈻戔枒鈻鈹敿鈹尖敿鈹尖敿鈹尖敿鈹杸鈻戔枒鈻戔枑鈻堚枅鈻堚枅"
            echo "鈻堚枅鈻堚枅鈻堚杽鈻戔枒鈻戔敂鈹粹敶鈹粹敶鈹粹敶鈹粹敇鈻戔枒鈻戔杽鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻堚枅鈻堚杽鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔枒鈻戔杽鈻堚枅鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻勨杽鈻勨杽鈻勨杽鈻勨枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻"
            echo "鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻堚枅鈻"
            echo ".....LOADING.....LOADING..."
            sleep 0.3
            clear 
        done
        ini=1
    else
        clear    
        echo "_________________________________________"
        echo "PGUTIL - Programa de Utilidad de Postgres"
        echo "_________________________________________"
        echo "             MENU PRINCIPAL              "
        echo "_________________________________________"
        echo "1. Instlar Postgres"
        echo "2. Desintalar Postgres"
        echo "3. Sacar un respaldo"
        echo "4. Restaurar respaldo"
        echo "5. Salir"

        read -n1 -p "Ingrese una opcion [1-5]:    " option

        echo -e "\n\n"

        case $option in
            1) 
                echo -e "Instalando"
                echo "Instalacion completada | usuario $(whoami) | $(date +'%d/%m/%Y %H:%M')" >> ./log/log_instalacion.txt
                sleep 2
                ;;
            2) 
                echo "Desintalando"
                echo "Desinstalacion completada | usuario $(whoami) | $(date +'%d/%m/%Y %H:%M')" >> ./log/log_desinstalacion.txt
                sleep 2
                ;;
            3) 
                echo "Respaldando"
                echo "respaldo completado | usuario $(whoami) | $(date +'%d/%m/%Y %H:%M')" >> ./log/log_respaldo.txt
                zip -e all_logs.zip ~/Desktop/script/proyecto/log/*.txt
#               rsync -avz $(pwd) [email protected](ip):direccionDestino
                sleep 2
                ;;
            4) 
                echo "Restaurando"
                echo "restauracion completada | usuario $(whoami) | $(date +'%d/%m/%Y %H:%M')" >> ./log/log_restauracion.txt
                sleep 2
                ;;
            5) 
                echo "Saliendo"
                echo "usuario $(whoami) salio del sistema | $(date +'%d/%m/%Y %H:%M')" >> ./log/log_usuario.txt
                exit 0
                ;;
        esac
    fi
donex
# ! /bin/bash
# Programa que permite manejar las utilizades de Postres
# Autor: Anthony SQC

if [[ -d "./logs" ]]; then
    echo "El directorio de logs ya existe, no voy a crear otro"
else
    echo "El directorio de logs no existe, voy a crearlo"
    mkdir -m 755 logs
fi


opcion=0
while :
do
    #Limpiar pantalla
    clear 
    #Imprimir menu
    echo "-----------------------------------------" 
    echo "PGUTIL - Programa de utilidad de Postgres"
    echo "-----------------------------------------" 
    echo "              MEN脷 PRINCIPAL             "
    echo "-----------------------------------------" 
    echo "1. Instalar Postgres"
    echo "2. Desintalar Postgres"
    echo "3. Sacar un registro"
    echo "4. Restar regsitro"
    echo "5. Salir"
    echo "7. Realizar backup y enviar por SSH"
    
    #Leer los datos del usuario - capturar informaci贸n
    read -n1 -p "Ingrese un opcion [1-5]" opcion

    #Validar la opcion ingresada
    case $opcion in
    1)
        cadena="\nInstalar Postgres.......\n"
        echo -e "$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e "$cadena" >> $logName
        sleep 3
        ;;
    2)
        cadena="\nDesintalar Postgres....\n"
        echo -e "$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e "$cadena" >> $logName
        sleep 3
        ;;
    3)
        cadena="\nSacar un registro.....\n"
        echo -e "$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e "$cadena" >> $logName
        sleep 3
        ;;
    4)
        cadena="\nRestaurar un registro.\n"
        echo -e "$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e "$cadena" >> $logName
        sleep 3
        ;;
    5)
        cadena="Salida del programa\n"
        echo -e "$cadena"
        fecha=`date +%Y%m%d%H%M%S`
        logName="./logs/log${fecha}.log"
        echo -e "$cadena" >> $logName
        break
        ;;
     7)
        tar -cvf backupEjecutables.tar ./*.sh
        zip -e backupEjecutables.tar.zip backupEjecutables.tar
        rsync -avz backupEjecutables.tar.zip [email protected]:${HOME}/recibosRSYNC
        rm backupEjecutables.tar.zip
        echo "Informacion enviada."
        break
        ;;
    esac
done


#!/bin/bash
#Programa realizada para el Reto 6 del curso de programaci贸n en Bash. 
#Toma los archivos y los empaqueta en tar. Por otra parte los empaqueta en zip con contrase帽a 
#y manda el paquete zip mediante rsync a la carpeta /home/Descargas, obteniendo del usuario 
#los datos de host y user.

option="Dentro_de_tu_ciudad_existe_otra_ciudad"
result="que_solo_茅l_conoce"

touch $option$(date +"%Y_%M_%d_%h_%m_%s").log
touch $result$(date +"%Y_%M_%d_%h_%m_%s").log


tar -cvzf paquete.tar Dentro_* que_*

zip -e paquete.zip Dentro_* que_*

user=""
host=""

read -p "Ingrese el host al que enviar el paquete.zip: " host
read -p "Ingrese el usuario al que enviar el paquete.zip: " user

rsync -avz paquete.zip [email protected]$host:/home/Descargas
<code>
#!/bin/bash
##Modificar archivo utiliHost.sh para empaquetar los log y enviarlos por ssh
#Autor: chichocoria

user=""
host=""

fechahora=$(date +%Y-%m-%d_%H%M%S)
touch prelog.log

option="Eligi脙鲁 la opcion correcta"
result="El resultado va a /dev/null"

echo $option >> prelog.log
echo $result >> prelog.log
echo -e "\nMostar los datos en el archivo .log"
cat prelog.log
##renombra archiv prelog.log con la fechahora
mv prelog.log $fechahora.log
echo -e "\nLista para mostrar el archivo log"
ls -lah | grep *.log

echo -e "\nEmpaquetar los logs en formato zip con usuario y clave"

zip  -e empalog.zip *.log

read -p "\nIngrese el host: " host
read -p "\nIngrese el usuario: " user

echo -e "\nEnviar archivo comprimido por la red"
sudo rsync -avh empalog.zip $user@$host:/home/chicho/

Listo

#!/bin/bash
user=鈥渦buntu"
server=鈥192.168.0.1"
path=鈥/home/ubuntu"
date=date +%Y%m%d%H%M%S
opcion=鈥"
log="log-$date.log"
echo -e "1)Procesos Actuales"
echo -e "2)Memoria Disponible"
echo -e "3)Espacio en Disco"
echo -e "4)Informaci贸n de Red"
echo -e "5)Variables de Entorno Configuradas"
echo -e "6)Informaci贸n Programa"
echo -e 鈥7)Backup informaci贸n鈥

read -n1 -p 鈥淚ngrese una opci贸n:鈥 opcion
echo 鈥溾

case $opcion in
1) ps aux > ps-$log && cat $PWD/$log ;;
2) free > mem-$log && cat $PWD/
$log;;
3) df -h > disk-$log && cat $PWD/$log ;;
4) ip a > net-$log && cat $PWD/
$log ;;
5) env > env-$log && cat $PWD/$log ;;
6) read -p 鈥淚ndique un programa: " pg
echo鈥"
whereis $pg > pg-$log && cat $PWD/
$log
;;
7) zip -e backup-$date.zip $PWD/.log > back-$log && cat $PWD/$log
scp backup-$date.zip [email protected]$server:$path
;;
*)
echo 鈥渙pcion no valida鈥
;;
esac

ahhh se refiere es al archivo **utilityPostgres.sh ** en el reto 5

Aqui va mi RETO6:

<h1>! /bin/bash</h1> <h1>RETO 6</h1> <h1>Autor: Paul Manrique</h1>

opcion=0
nombre="鈥
backup=鈥濃
host=鈥濃
user=鈥濃
ruta=鈥"

while :
do

#Desplegar el men煤 de opciones
echo "###########################################"
echo "############# MEN脷 PRINCIPAL ##############"
echo "###########################################"
echo "1. Instalar Actualizacion"
echo "2. Desinstalar Actualizacion"
echo "3. Eliminar Actualizacion"
echo "4. Restaurar Actualizacion"
echo "5. Reinstalar Actualizacion"
echo "6. Limpiar Archivos Obsoletos"
echo "7. Backup de Informaci贸n"
echo 鈥8. Salir鈥

#Leer los datos del usuario - capturar informaci贸n
read -n1 -p 鈥淚ngrese una opci贸n [1-8]:鈥 opcion

#Validar la opci贸n ingresada
case $opcion in

1-6)
echo -e "\nRealizando solicitud del usuario鈥5%"
sleep 30s
echo -e "\nRealizando solicitud del usuario鈥25%"
sleep 30s
echo -e "\nRealizando solicitud del usuario鈥35%"
sleep 30s
echo -e "\nRealizando solicitud del usuario鈥50%"
sleep 30s
echo -e "\nRealizando solicitud del usuario鈥75%"
sleep 30s
echo -e "\nRealizando solicitud del usuario鈥100%"
sleep 30s
echo -e "\nSolicitud Realizada鈥100%"
sleep 30s
clear
;;

echo -e "\nBackup de Informacion"
read -p 鈥淚ngresar Usuario:鈥 nombre
read -p 鈥淚ngrese nombre backup:鈥 backup
read -p "Ingrese host: " host
read -p "Ingrese usuario: " user
read -p "Ingrese ruta para backup: " ruta

echo -e "\nNombre Usuario: $nombre"
echo -e "\nNombre del Backup es: $backup"
echo -p "Ingrese host: $host"
echo -p "Ingrese usuario: $user"
echo -p 鈥渓a ruta en donde quiera hacer el backup: $ruta鈥

touch $(date +"%Y_%m_%d_%H_%M_%S").log
fecha=$(date +"%A-%d-%B-%Y-%k-%M-%S")

echo $nombre >> $(date +"%Y_%m_%d_%H_%M_%S").log
echo $backup >> $(date +"%Y_%m_%d_%H_%M_%S").log
echo $fecha >> $(date +"%Y_%m_%d_%H_%M_%S").log

#empaquetar los logs generados utilizando ZIP
zip -e BACKUP_$fecha.zip *.log

#Transferir el archivo .ZIP a una ruta especifica
rsync -avz BACKUP_$fecha.zip [email protected]$host:$ruta
sleep 3
;;
8)
echo "Salir del Programa"
exit 0
;;
esac
done

<# ! /bin/bash
#Programa que permite validar el reto 6 
#Autor: Oscar Vargas @EcoGeekco

echo -e "


                __             ________
_______   _____/  |_  ____    /  _____/
\_  __ \_/ __ \   __\/  _ \  /   __  \ 
 |  | \/\  ___/|  | (  <_> ) \  |__\  \
 |__|    \___  >__|  \____/   \_____  /
             \/                     \/ 
                                                                                    
                                                                                   
"


opcion=0

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. Variables de entorno configuradas"
   echo "6. Informacion programa "
   echo "7. Backup informaci贸n"
   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."
     top
     sleep 5
     ;;
  2)
     echo -e "\n Memoria Disponible."
     free -h
     sleep 5
     ;;
  3)
     echo -e "\n Espacio en disco....."
     df -h
     sleep 5
     ;;
  4)
     echo -e  "\n Informacion Red....."
     netstat -tulpn
     sleep 5
     ;;
  5)
     echo -e  "\n Variables de entorno configuradas....."
     env -u VAR
     sleep 5
     ;;
  6)
     echo -e "\n Informacion Programa"
     dpkg -l | more
     sleep 5
     ;;
  7)
     echo -e  "\n Comprimir archivos"

    date=$(date '+%Y%m%d%H%M%S')
    touch $date.log
    cat *.sh  >> $date.log
    sleep 1
    cat /var/log/syslog >> $date.log
    sleep 1
    cat /etc/passwd >> $date.log
    sleep 1

    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

     echo "done"
     sleep 30
     ;;
  8)
    echo -e "\n Saliendo Muchas Gracias "
    exit 0
    ;;
  esac
done>
#!/bin/bash
#Programa para ejecutar las opciones solicitadas
#Autor: Harvi Calle - @harvif

opcion=0

while : #While infinito hasta que se ejecute centencia
do
    #Limpieza de pantalla
    clear

echo  "         _     _
        |+|   |+|
        |+|   |+|      _        ___    __         __  _
        |+|___|+|     /A\     |R R R\  \V\       /V/ |+|
        |+ ___ +|    /A_A\    |R|  \R\  \V\     /V/  |+|
        |+|   |+|   /A/_\A\   |R|__/R/   \V\   /V/   |+|
        |+|   |+|  /A +++ A\  |R++++R\    \V\ /V/    |+|
        |+|   |+| /A/     \A\ |R|   \R\    \ V /     |+|"

    #Desplegar menu de opciones
    echo "_________________________________________"
    echo "              RETO 4 Platzi             "
    echo "_________________________________________"
    echo "                 Opciones                "
    echo "_________________________________________"
    echo "1. Mostrar los procesos de Mayor consumo"
    echo "2. Mostrar la memoria disponible en GB"
    echo "3. Espacio en disco."
    echo "4. Mostrar las IP y tarjeta de red."
    echo "5. Variables de entorno configuradas."
    echo "6. Informacion Programas ejecutados con usuario actual."
    echo "7. Backup de Informacion."
    echo "8. Ingrese una opcion."
    echo "9. Salir"
    echo "_________________________________________"

utilitylog=/tmp/utilityHost.log
touch $utilitylog
echo "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" >> $utilitylog
echo "+++++++Inicia ejecucion de script a las $(date +%Y-%m-%d_%H:%M:%S) ++++++" >> $utilitylog
    #Leer los datos del usuario 
    read -n1 -p "Ingrese una opcion [1-9]: " opcion
echo "La opcion seleccionada fue $opcion" >> $utilitylog

    #validar la opcion ingresada
    case $opcion in
        1)  
            echo -e "\nTop 10 de Procesos de Mayor consumo de memoria:"
            ps -eo cmd,%mem,%cpu --sort=-%mem | head | tee $utilitylog
            echo -e "\nPresione una tecla para continuar"
            read -n1
            ;;
        2) 
            echo -e  "\nLa memoria RAM libre en Gi es."
            free -gh | tee $utilitylog
            echo -e "\nPresione una tecla para continuar"
            read -n1
            ;;
        3) 
            echo -e "\nEl espacio disponible en disco es..."
            df -h | tee $utilitylog
            echo -e "\nPresione una tecla para continuar"
            read -n1
            ;;
        4) 
            echo -e "\nLas IP configuradas en el computador son:"
            netstat -nt | awk '{ print $4 }' | awk -F ':' '{ print $1 }' | uniq | tail -n 1 | tee $utilitylog
            echo -e "\nPresione una tecla para continuar"
            read -n1
            ;;
        5) 
            echo -e "\nLas IP configuradas en el computador son:"
            printenv | tee $utilitylog
            echo -e "\nPresione una tecla para continuar"
            read -n1
            ;;
        6) 
            echo -e "\nInformacion de programas ejecutandose con usuario actual:"
            ps -axu | grep $(whoami) | awk '{ print $11}' | tee $utilitylog
            echo -e "\nPresione una tecla para continuar"
            read -n1
            ;;
        7) 
            echo -e "\nBackup del directorio Home, almacenado en /tmp"
            usuario=""
            host=""
            rutadestino=""
            tar -czvf home_$(date %F).tar.gz /home/$(whoami)/Desktop | tee $utilitylog
            rsync -avz home_$(date %F).tar.gz $user@$host:$rutadestino | tee $utilitylog
            sleep 1
            ;;
        8) 
            read -p "\nIngresa tu fecha de nacimiento [yyyymmdd]: " natalicio
            echo -e "\nEstos son algunos eventos importantes ocurridos un dia como el que naciste:"
            calendar -t $natalicio | tee $utilitylog
            echo -e "\nPresione una tecla para continuar"
            read -n1
            ;;
        9) 
            echo -e "\nSalir del programa"
            echo -e "\nEjecucion finalizada a las $(date +%C)" >> $utilitylog
            exit 0
    esac
done```

Aqu铆 mi c贸digo.

# !/bin/bash
# Reto 6: Modificar el programa utilityHost.sh para empaquetar los logs generados, utilizando alg煤n formato de compresi贸n. Colocarle una clave y pasarlo a otra m谩quina a trav茅s de SSH, todo 茅sto, cuando se seleccione la opci贸n 7. Backup informaci贸n.
# 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=""

# 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 6                                         "
    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 -e "\nProcesos actuales"
            echo "$usuario|$momento|Seleccion贸: Procesos actuales" >> $repo/log$fecha.log
            sleep 3
            ;;
        2)
            echo -e "\nMemoria disponible"
            echo "$usuario|$momento|Seleccion贸: Memoria disponible" >> $repo/log$fecha.log
            sleep 3
            ;;
        3)
            echo -e "\nEspacio en disco"
            echo "$usuario|$momento|Seleccion贸: Espacio en disco" >> $repo/log$fecha.log
            sleep 3
            ;;
        4)
            echo -e "\nInformaci贸n de red"
            echo "$usuario|$momento|Seleccion贸: Informaci贸n de red" >> $repo/log$fecha.log
            sleep 3
            ;;
        5)
            echo -e "\nVariables de entorno configuradas"
            echo "$usuario|$momento|Seleccion贸: Variables de entorno configuradas" >> $repo/log$fecha.log
            sleep 3
            ;;
        6)
            echo -e "\nInformaci贸n programa"
            echo "$usuario|$momento|Seleccion贸: Informaci贸n del programa" >> $repo/log$fecha.log
            sleep 3
            ;;
        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 
#!/bin/bash
#Declarar 2 variables e imprimir sus resultados
option=`uname -a`
result=$(date)
fecha=`date +%Y%m%d_%H%M%S`
usuario=""
host=""
echo -e "$result \n$option" > log_$fecha.txt
echo "compresion del log"
zip -e log_$fecha.zip log_$fecha.txt
echo -e "\ntranferir archivo" 
read -p "Ingrese usuario: " usuario
read -p "Ingrese host destino: " host
rsync -avz log_$fecha.zip $usuario@$host:/tmp/platzi/

Done!

Challenge 6.