Dieses Forum nutzt Cookies

**s.kranz** · (Dieser Beitrag wurde zuletzt bearbeitet: 09-02-2019, 10:37 AM von stephan.)

Für alle die nur einen VMware ESXi Server als Stand-Alone System einsetzen, aber komfortabel und sicher die virtuellen Maschinen sichern möchten, gibt es eine kostenfreie Alternative:

Es wird ein Skript auf dem ESXi installiert, welches die Sicherung der einzelnen VMs durchführt. Das Sicherungsziel kann ein NFS-Speicher, iSCSI Storage oder FC-Storage sein. Das Skript ist voll automatisierbar und kostenfrei.

Eine Haken gibt es natürlich: Das ESXi ist eigentlich gegen fremde Skripte geschützt und die Console ist auch eigentlich nur für den Support gedacht. Aber für alle die das nicht stört, eine gute und schnelle Sicherung von VMs. Das "Öffnen" des ESXi ist auch beschrieben.

Weitere Infos, die Anleitung und das Skript gibt es unter:
ghettoVCB zur kostengünstigen Sicherung von VMware ESXi

Ich hoffe, dies kann einigen etwas weiterhelfen ...

joni2000de · 15-02-2010, 07:19 PM

Hi,
ich habe das Ganze wie in der Anleitung beschrieben durchgeführt. Beim händischen Ausführen des Scripts erhalte ich Permission denied. Da ich mit Linux bisher fast keine Erfahrungen habe wäre ich über Hilfe bei der Problemlösung froh.
Gruß Joni

**s.kranz** · 15-02-2010, 08:49 PM

Hi Joni,
wann bekommst Du denn das Permission Denied? Gleich beim Starten des Skriptes? Hast Du das Skript ausführbar gemacht? Also erst ein chmod 750 ghettoVCB.sh. Wenn's das nicht ist, welchen Speicher möchtest Du verwenden (NFS, VMFS)? Welchen User nutzt Du auf der Console des ESXi?
Am besten mal den Auszug aus der Console (bzw. das putty Fenster) posten.

Gruß
Stephan

joni2000de · 16-02-2010, 02:22 PM

Hallo Stephan,

dank deiner Hilfe bin ich schon einen Schritt weiter. Das mit dem Ausführbarmachen hatte ich übersehen. Naja, wer lesen kann ist klar im Vorteil :-)

Aber viel weiter bin ich trotzdem noch nicht. Hier das Script das ausgeführt werden soll (aus dem Windowseditor).

Code:
# Author: william2003[at]gmail[dot]com

# Date: 11/01/2008

#

# This script is cron'd everyday to run backups on certain set of VMs and will overwite the previous backup if exists

# directory that all VM backups should go (e.g. /vmfs/volumes/SAN_LUN1/mybackupdir)

VM_BACKUP_VOLUME=/vmfs/volumes/datastore2/backup

# Format output of VMDK backup

# 1 = zeroedthick

# 2 = 2gbsparse

# 3 = thin

# 4 = eagerzeroedthick

VMDK_OUTPUT_FORMAT=1

# Number of backups for a given VM before deleting

VM_BACKUP_ROTATION_COUNT=3

# Directory naming convention for backup rotations (please ensure there are no spaces!)

VM_BACKUP_DIR_NAMING_CONVENTION="$(date +%F)" 

# Shutdown guestOS prior to running backups and power them back on afterwards

# This feature assumes VMware Tools are installed, else they will not power down and loop forever

# 1=on, 0 =off

POWER_VM_DOWN_BEFORE_BACKUP=1

# enable shutdown code 1=on, 0 = off

ENABLE_HARD_POWER_OFF=0

# if the above flag "ENABLE_HARD_POWER_OFF "is set to 1, then will look at this flag which is the # of iterations

# the script will wait before executing a hard power off, this will be a multiple of 3

# (e.g) = 4, which means this will wait up to 12secs before it just powers off the VM

ITER_TO_WAIT_SHUTDOWN=4

# enable compression with gzip+tar 1=on, 0=off

ENABLE_COMPRESSION=0

##########################################################

# NON-PERSISTENT NFS-BACKUP ONLY

# 

# ENABLE NON PERSISTENT NFS BACKUP 1=on, 0=off

ENABLE_NON_PERSISTENT_NFS=0

# umount NFS datastore after backup is complete 1=yes, 0=no

UNMOUNT_NFS=0

# IP Address of NFS Server

NFS_SERVER=172.30.0.195

# Path of exported folder residing on NFS Server (e.g. /some/mount/point )

NFS_MOUNT=/nfsshare

# Non-persistent NFS datastore display name of choice

NFS_LOCAL_NAME=nfs_storage_backup

# Name of backup directory for VMs residing on the NFS volume

NFS_VM_BACKUP_DIR=mybackups 

###########################################################

# DO NOT MODIFY PAST THIS LINE # 

DEVEL_MODE=0

printUsage() {

    SCRIPT_PATH=$(basename $0)

    echo -e "\nUsage: ${SCRIPT_PATH} [VM_FILE_INPUT]\n"

    exit

}

checkVMBackupRotation() {

    local BACKUP_DIR_PATH=$1

    local BACKUP_VM_NAMING_CONVENTION=$2

    LIST_BACKUPS=$(ls -tr "${BACKUP_DIR_PATH}")

    #default rotation if variable is not defined

    if [ -z ${VM_BACKUP_ROTATION_COUNT} ]; then

        VM_BACKUP_ROTATION_COUNT=1

    fi

    IFS='

'

    for DIR in ${LIST_BACKUPS};

    do

        TMP_DIR="${BACKUP_DIR_PATH}/${DIR}"

        TMP=$(echo ${TMP_DIR##*--})

            if [ ${TMP} = "${BACKUP_VM_NAMING_CONVENTION}" ]; then

                    NEW=${TMP}--1

                    mv "${BACKUP_DIR_PATH}/${DIR}" "${NEW}"

            elif [ $TMP -ge ${VM_BACKUP_ROTATION_COUNT} ]; then

                    rm -rf "${BACKUP_DIR_PATH}/${DIR}"

            else

            BASE=$(echo ${TMP_DIR%--*})

                    NEW=${BASE}--$((${TMP}+1))

                    mv "${BACKUP_DIR_PATH}/${DIR}" "$NEW"

            fi

    done    

    unset IFS

}

checkVMBackupRotationWCompresssion() {

        local BACKUP_DIR_PATH=$1

        local BACKUP_VM_NAMING_CONVENTION=$2

        LIST_BACKUPS=$(ls -tr "${BACKUP_DIR_PATH}")

        #default rotation if variable is not defined

        if [ -z ${VM_BACKUP_ROTATION_COUNT} ]; then

                VM_BACKUP_ROTATION_COUNT=1

        fi

        IFS='

'

        for DIR in ${LIST_BACKUPS};

        do

                TMP_DIR="${BACKUP_DIR_PATH}/${DIR}"

                TMP_ZIP=$(echo ${TMP_DIR%*.gz})

                TMP=$(echo ${TMP_ZIP##*--})

                if [ "${TMP}.gz" = "${BACKUP_VM_NAMING_CONVENTION}" ]; then

                        NEW=${TMP}--1

                        mv "${BACKUP_DIR_PATH}/${DIR}" "${NEW}.gz"

                elif [ $TMP -ge ${VM_BACKUP_ROTATION_COUNT} ]; then

                        rm "${BACKUP_DIR_PATH}/${DIR}"

                else

                        BASE=$(echo ${TMP_ZIP%--*})

                        NEW=${BASE}--$((${TMP}+1))

                        mv "${BACKUP_DIR_PATH}/${DIR}" "$NEW.gz"

                fi

        done

        unset IFS

}

sanityCheck() {

    NUM_OF_ARGS=$1

    if [ ! ${NUM_OF_ARGS} == 1 ]; then

        printUsage

    fi

    if [ -f /usr/bin/vmware-vim-cmd ]; then

            VMWARE_CMD=/usr/bin/vmware-vim-cmd

        VMKFSTOOLS_CMD=/usr/sbin/vmkfstools

    elif [ -f /bin/vim-cmd ]; then

            VMWARE_CMD=/bin/vim-cmd

        VMKFSTOOLS_CMD=/sbin/vmkfstools

    else

            echo "You're not running ESX(i) 3.5+ or 4.0+!"

            exit

    fi

    ESX_VERSION=$(vmware -v | awk '{print $3}')

        if [ "${ESX_VERSION}" == "4.0.0" ]; then

            VER=4

        else

        ESX_VERSION=$(vmware -v | awk '{print $4}')

        if [[ "${ESX_VERSION}" == "3.5.0" ]] || [[ "${ESX_VERSION}" == "3i" ]]; then

            VER=3

        else

            echo "You're not running ESX(i) 3.5+ or 4.0+!"

                    exit

        fi

        fi

    if [ ${ENABLE_NON_PERSISTENT_NFS} -eq 1 ]; then

        ${VMWARE_CMD} hostsvc/summary/fsvolume | awk '{print $1'} | grep "\"${NFS_LOCAL_NAME}\"" > /dev/null 2>&1

        if [ ! $? -eq 0 ]; then

            #1 = readonly

            #0 = readwrite

            ${VMWARE_CMD} hostsvc/datastore/nas_create "${NFS_LOCAL_NAME}" "${NFS_SERVER}" "${NFS_MOUNT}" 0 

        fi

    fi

    if [ ! -f ${FILE_INPUT} ]; then

        echo -e "Error: ${FILE_INPUT} is not a valid VM input file!\n"

        printUsage

    fi

    if [ ! "`whoami`" == "root" ]; then

          echo "This script needs to be executed by \"root\"!"

            exit 1

    fi

}

ghettoVCB() {

    VM_INPUT=$1

        START_TIME=`date`

        S_TIME=`date +%s`

    #dump out all virtual machines allowing for spaces now

    ${VMWARE_CMD} vmsvc/getallvms | sed 's/[[:blank:]]\{3,\}/   /g' | awk -F'   ' '{print "\""$1"\";\""$2"\";\""$3"\""}' |  sed 's/\] /\]\";\"/g' | sed '1,1d' > /tmp/vms_list

    ORIG_IFS=${IFS}

    IFS='

'

    for VM_NAME in `cat "${VM_INPUT}" | sed '/^$/d' | sed -e 's/^[[:blank:]]*//;s/[[:blank:]]*$//'`;

        do

        VM_ID=`grep -E "\"${VM_NAME}\"" /tmp/vms_list | awk -F ";" '{print $1}' | sed 's/"//g'`

        #ensure default value if one is not selected or variable is null

        if [ -z ${VM_BACKUP_DIR_NAMING_CONVENTION} ]; then

            VM_BACKUP_DIR_NAMING_CONVENTION="$(date +%F)"

        fi

        VMFS_VOLUME=`grep -E "\"${VM_NAME}\"" /tmp/vms_list | awk -F ";" '{print $3}' | sed 's/\[//;s/\]//;s/"//g'`

        VMX_CONF=`grep -E "\"${VM_NAME}\"" /tmp/vms_list | awk -F ";" '{print $4}' | sed 's/\[//;s/\]//;s/"//g'`

        VMX_PATH="/vmfs/volumes/${VMFS_VOLUME}/${VMX_CONF}"

        VMX_DIR=`dirname "${VMX_PATH}"`

        #checks to see if we can pull out the VM_ID

        if [ -z ${VM_ID} ]; then

            echo "Error: failed to extract VM_ID for ${VM_NAME}!"

        #devel mode

        elif [ ${DEVEL_MODE} -eq 1 ]; then

            echo "##########################################"

            echo "Virtual Machine: $VM_NAME"

            echo "VM_ID: $VM_ID"

            echo "VMX_PATH: $VMX_PATH"

            echo "VMX_DIR: $VMX_DIR"

            echo "VMX_CONF: $VMX_CONF"

            echo "VMFS_VOLUME: $VMFS_VOLUME"

            echo -e "##########################################\n"

                #checks to see if the VM has any snapshots to start with

                elif ls "${VMX_DIR}" | grep -q delta > /dev/null 2>&1; then

                    echo "Snapshot found for ${VM_NAME}, backup will not take place"

        #checks to see if the VM has an RDM 

        #elif ${VMWARE_CMD} vmsvc/device.getdevices ${VM_ID} | grep "RawDiskMapping" > /dev/null 2>&1; then

        #    echo "RDM was found for ${VM_NAME}, backup will not take place"

                elif [[ -f "${VMX_PATH}" ]] && [[ ! -z "${VMX_PATH}" ]]; then

             #nfs case and backup to root path of your NFS mount     

                    if [ ${ENABLE_NON_PERSISTENT_NFS} -eq 1 ] ; then 

                        BACKUP_DIR="/vmfs/volumes/${NFS_LOCAL_NAME}/${NFS_VM_BACKUP_DIR}/${VM_NAME}"

                                if [[ -z ${VM_NAME} ]] || [[ -z ${NFS_LOCAL_NAME} ]] || [[ -z ${NFS_VM_BACKUP_DIR} ]]; then

                                        echo "Variable BACKUP_DIR was not set properly, please ensure all required variables for non-persistent NFS backup option has been defined"

                                        exit 1

                                fi

                      #non-nfs (SAN,LOCAL)      

                    else

                        BACKUP_DIR="${VM_BACKUP_VOLUME}/${VM_NAME}"

                                if [[ -z ${VM_BACKUP_VOLUME} ]]; then

                                        echo "Variable VM_BACKUP_DIR was not defined"

                                        exit 1

                                fi

                    fi

            #initial root VM backup directory

            if [ ! -d "${BACKUP_DIR}" ]; then

                mkdir -p "${BACKUP_DIR}"

                if [ ! -d "${BACKUP_DIR}" ]; then

                    echo "Unable to create \"${BACKUP_DIR}\"! - Ensure VM_BACKUP_VOLUME was defined correctly"

                    exit 1

                fi

                    fi

            # directory name of the individual Virtual Machine backup followed by naming convention followed by count

            VM_BACKUP_DIR="${BACKUP_DIR}/${VM_NAME}-${VM_BACKUP_DIR_NAMING_CONVENTION}"

            mkdir -p "${VM_BACKUP_DIR}"

            cp "${VMX_PATH}" "${VM_BACKUP_DIR}"

            #get all VMDKs listed in .vmx file

            VMDKS_FOUND=`grep -iE '(scsi|ide)' "${VMX_PATH}" | grep -i fileName | awk -F " " '{print $1}'`

            TMP_IFS=${IFS}

                        IFS=${ORIG_IFS}

            #loop through each disk and verify that it's currently present and create array of valid VMDKS

            for DISK in ${VMDKS_FOUND};

            do

                #extract the SCSI ID and use it to check for valid vmdk disk

                SCSI_ID=`echo ${DISK%%.*}`

                grep -i "${SCSI_ID}.present" "${VMX_PATH}" | grep -i "true" > /dev/null 2>&1

                #if valid, then we use the vmdk file

                if [ $? -eq 0 ]; then

                        grep -i "${SCSI_ID}.deviceType" "${VMX_PATH}" | grep -i "scsi-hardDisk" > /dev/null 2>&1

                                        #if we find the device type is of scsi-disk, then proceed

                                        if [ $? -eq 0 ]; then

                                                DISK=`grep -i ${SCSI_ID}.fileName "${VMX_PATH}" | awk -F "\"" '{print $2}'`

                                                VMDKS="${DISK}:${VMDKS}"

                                        else

                                                #if the deviceType is NULL for IDE which it is, thanks for the inconsistency VMware

                                                #we'll do one more level of verification by checking to see if an ext. of .vmdk exists

                                                #since we can not rely on the deviceType showing "ide-hardDisk"

                                                grep -i ${SCSI_ID}.fileName "${VMX_PATH}" | grep -i ".vmdk" > /dev/null 2>&1

                                                if [ $? -eq 0 ]; then

                                                        DISK=`grep -i ${SCSI_ID}.fileName "${VMX_PATH}" | awk -F "\"" '{print $2}'`

                                                        VMDKS="${DISK}:${VMDKS}"

                                                fi

                                        fi

                                fi

                        done

                        IFS=${TMP_IFS}

            ORGINAL_VM_POWER_STATE=$(${VMWARE_CMD} vmsvc/power.getstate ${VM_ID} | tail -1)

            #section that will power down a VM prior to taking a snapshot and backup and power it back on

            if [ ${POWER_VM_DOWN_BEFORE_BACKUP} -eq 1 ]; then

                START_ITERATION=0

                echo "Powering off initiated for ${VM_NAME}, backup will not begin until VM is off..."

                ${VMWARE_CMD} vmsvc/power.shutdown ${VM_ID} > /dev/null 2>&1

                while ${VMWARE_CMD} vmsvc/power.getstate ${VM_ID} | grep -i "Powered on" > /dev/null 2>&1;

                do

                    #enable hard power off code

                    if [ ${ENABLE_HARD_POWER_OFF} -eq 1 ]; then

                        START_ITERATION=$((START_ITERATION + 1))

                        if [ ${START_ITERATION} -gt ${ITER_TO_WAIT_SHUTDOWN} ]; then

                            echo "Hard power off occured for ${VM_NAME}, waited for $((ITER_TO_WAIT_SHUTDOWN*3)) seconds" 

                            ${VMWARE_CMD} vmsvc/power.off ${VM_ID} > /dev/null 2>&1 

                            #this is needed for ESXi, even the hard power off did not take affect right away

                            sleep 5

                            break

                        fi

                    fi

                                        echo "VM is still on - Iteration: ${START_ITERATION} - waiting 3secs"

                                        sleep 3

                done 

                echo "VM is off"

            fi

            #powered on VMs only

                        if [[ ! ${POWER_VM_DOWN_BEFORE_BACKUP} -eq 1 ]] && [[ "${ORGINAL_VM_POWER_STATE}" != "Powered off" ]]; then

                                echo "################ Taking backup snapshot for ${VM_NAME} ... ################"

                                ${VMWARE_CMD} vmsvc/snapshot.create ${VM_ID} vcb_snap VCB_BACKUP_${VM_NAME}_`date +%F` > /dev/null 2>&1

                        else

                                echo "################## Starting backup for ${VM_NAME} ... #####################"

                        fi

            echo "Start time: $(date)"

            OLD_IFS="${IFS}"

            IFS=":"

            for j in ${VMDKS};

            do

                VMDK="${j}"

                #added this section to handle VMDK(s) stored in different datastore than the VM

                echo ${VMDK} | grep "^/vmfs/volumes" > /dev/null 2>&1

                if [ $? -eq 0 ]; then

                    SOURCE_VMDK="${VMDK}"

                    DS_UUID="$(echo ${VMDK#/vmfs/volumes/*})"

                    DS_UUID="$(echo ${DS_UUID%/*/*})"

                    VMDK_DISK="$(echo ${VMDK##/*/})"

                    mkdir -p "${VM_BACKUP_DIR}/${DS_UUID}"

                    DESTIONATION_VMDK="${VM_BACKUP_DIR}/${DS_UUID}/${VMDK_DISK}"

                else

                    SOURCE_VMDK="${VMX_DIR}/${VMDK}"

                    DESTIONATION_VMDK="${VM_BACKUP_DIR}/${VMDK}"

                fi

            #support for vRDM and deny pRDM

            grep "vmfsPassthroughRawDeviceMap" "${SOURCE_VMDK}" > /dev/null 2>&1

            if [ $? -eq 1 ]; then

                    if [ ${VMDK_OUTPUT_FORMAT} -eq 1 ]; then

                        if [ "${VER}" == "4" ]; then 

                                                ${VMKFSTOOLS_CMD} -i "${SOURCE_VMDK}" -d zeroedthick "${DESTIONATION_VMDK}"

                        else 

                            ${VMKFSTOOLS_CMD} -i "${SOURCE_VMDK}" "${DESTIONATION_VMDK}"

                        fi

                                    elif [ ${VMDK_OUTPUT_FORMAT} -eq 2 ]; then

                                            ${VMKFSTOOLS_CMD} -i "${SOURCE_VMDK}" -d 2gbsparse "${DESTIONATION_VMDK}"

                                    elif [ ${VMDK_OUTPUT_FORMAT} -eq 3 ]; then

                                            ${VMKFSTOOLS_CMD} -i "${SOURCE_VMDK}" -d thin "${DESTIONATION_VMDK}"

                                    elif [ ${VMDK_OUTPUT_FORMAT} -eq 4 ]; then

                        if [ "${VER}" == "4" ]; then

                                                    ${VMKFSTOOLS_CMD} -i "${SOURCE_VMDK}" -d eagerzeroedthick "${DESTIONATION_VMDK}"

                                            else

                                                    ${VMKFSTOOLS_CMD} -i "${SOURCE_VMDK}" "${DESTIONATION_VMDK}"

                                            fi

                                    fi

            else

                                echo "WARNING: A physical RDM \"${SOURCE_VMDK}\" was found for ${VM_NAME}, which will not be backed up"

                        fi

            done

            IFS="${OLD_IFS}"

            #powered on VMs only w/snapshots

                        if [[ ! ${POWER_VM_DOWN_BEFORE_BACKUP} -eq 1 ]] && [[ "${ORGINAL_VM_POWER_STATE}" == "Powered on" ]]; then

                                ${VMWARE_CMD} vmsvc/snapshot.remove ${VM_ID} > /dev/null 2>&1

                                #do not continue until all snapshots have been committed

                                echo "Removing snapshot from ${VM_NAME} ..."

                                while ls "${VMX_DIR}" | grep -q delta;

                                do

                                        sleep 3

                                done

                        fi

            if [[ ${POWER_VM_DOWN_BEFORE_BACKUP} -eq 1 ]] && [[ "${ORGINAL_VM_POWER_STATE}" == "Powered on" ]]; then

                                #power on vm that was powered off prior to backup

                                echo "Powering back on ${VM_NAME}"

                                ${VMWARE_CMD} vmsvc/power.on ${VM_ID} > /dev/null 2>&1

                        fi

            TMP_IFS=${IFS}

                        IFS=${ORIG_IFS}

                        if [ ${ENABLE_COMPRESSION} -eq 1 ]; then

                                echo "Compressing VM backup \"${BACKUP_DIR}/${VM_NAME}-${VM_BACKUP_DIR_NAMING_CONVENTION}.gz\"..."

                if [ ${IS_4I} -eq 1 ]; then

                    busybox tar -cz -C "${BACKUP_DIR}" "${VM_NAME}-${VM_BACKUP_DIR_NAMING_CONVENTION}" -f "${BACKUP_DIR}/${VM_NAME}-${VM_BACKUP_DIR_NAMING_CONVENTION}.gz"

                else 

                    tar -cz -C "${BACKUP_DIR}" "${VM_NAME}-${VM_BACKUP_DIR_NAMING_CONVENTION}" -f "${BACKUP_DIR}/${VM_NAME}-${VM_BACKUP_DIR_NAMING_CONVENTION}.gz"

                fi

                                rm -rf "${VM_BACKUP_DIR}"

                                checkVMBackupRotationWCompresssion "${BACKUP_DIR}" "${VM_BACKUP_DIR}.gz"

                        else

                                checkVMBackupRotation "${BACKUP_DIR}" "${VM_BACKUP_DIR}"

                        fi

                        IFS=${TMP_IFS}

                        VMDKS=""

            echo "End time: $(date)"

            echo -e "#################### Completed backup for ${VM_NAME}! ####################\n"

                else

                        echo "Error: failed to lookup ${VM_NAME}!"

                fi

        done

    unset IFS

        if [[ ${ENABLE_NON_PERSISTENT_NFS} -eq 1 ]] && [[ ${UNMOUNT_NFS} -eq 1 ]] ; then

        ${VMWARE_CMD} hostsvc/datastore/destroy ${NFS_LOCAL_NAME}    

    fi

    echo

        END_TIME=`date`

        E_TIME=`date +%s`

        echo "Start time: ${START_TIME}"

        echo "End   time: ${END_TIME}"

        DURATION=`echo $((E_TIME - S_TIME))`

        #calculate overall completion time

        if [ ${DURATION} -le 60 ]; then

                echo "Duration  : ${DURATION} Seconds"

        else

                echo "Duration  : `awk 'BEGIN{ printf "%.2f\n", '${DURATION}'/60}'` Minutes"

        fi

    echo -e "\nCompleted backing up specified Virtual Machines!\n"

}

####################

#           #

# Start of Script  #

#           #

####################

IS_4I=0

if [ ! -f /bin/bash ]; then

    IS_4I=1

fi

#performs a check on the number of commandline arguments + verifies $2 is a valid file

sanityCheck $#

ghettoVCB $1

Beim Ausführen erhalte ich folgende Meldungen:

Code:
: not found.sh: line 5:

: not found.sh: line 8:

: not found.sh: line 15:

: not found.sh: line 18:

: not found.sh: line 20:

: not found.sh: line 21:

: not found.sh: line 26:

: not found.sh: line 29:

: not found.sh: line 34:

: not found.sh: line 37:

: not found.sh: line 42:

: not found.sh: line 44:

: not found.sh: line 47:

: not found.sh: line 50:

: not found.sh: line 53:

: not found.sh: line 56:

: not found.sh: line 58:

: not found.sh: line 59:

: not found.sh: line 61:

: not found.sh: line 63:

: not found.sh: line 65:

 [VM_FILE_INPUT].sh

: not found.sh: line 69: exit

: not found.sh: line 70: }

: not found.sh: line 71:

: No such file or directory

: not found.sh: line 76:

./ghettoVCB.sh: line 84: syntax error: word unexpected (expecting "do")

Wenn ich mir das Script dann mit vi ansehe sind an diesen Stellen immer ^M angeführt (scheint für die Zeilenschaltung zu stehen). Nachfolgend ein Auszug:

Code:
# Author: william2003[at]gmail[dot]com^M

# Date: 11/01/2008^M

#^M

# This script is cron'd everyday to run backups on certain set of VMs and will overw

^M

# directory that all VM backups should go (e.g. /vmfs/volumes/SAN_LUN1/mybackupdir)^

VM_BACKUP_VOLUME=/vmfs/volumes/datastore2/backup^M

^M

# Format output of VMDK backup^M

# 1 = zeroedthick^M

# 2 = 2gbsparse^M

# 3 = thin^M

# 4 = eagerzeroedthick^M

VMDK_OUTPUT_FORMAT=1^M

^M

# Number of backups for a given VM before deleting^M

VM_BACKUP_ROTATION_COUNT=3^M

^M

# Directory naming convention for backup rotations (please ensure there are no space

VM_BACKUP_DIR_NAMING_CONVENTION="$(date +%F)" ^M

^M

# Shutdown guestOS prior to running backups and power them back on afterwards^M

# This feature assumes VMware Tools are installed, else they will not power down and

# 1=on, 0 =off^M

POWER_VM_DOWN_BEFORE_BACKUP=1^M

^M

# enable shutdown code 1=on, 0 = off^M

ENABLE_HARD_POWER_OFF=0^M

^M

# if the above flag "ENABLE_HARD_POWER_OFF "is set to 1, then will look at this flag

# the script will wait before executing a hard power off, this will be a multiple of

# (e.g) = 4, which means this will wait up to 12secs before it just powers off the V

ITER_TO_WAIT_SHUTDOWN=4^M

^M

# enable compression with gzip+tar 1=on, 0=off^M

ENABLE_COMPRESSION=0^M

^M

##########################################################^M

# NON-PERSISTENT NFS-BACKUP ONLY^M

# ^M

# ENABLE NON PERSISTENT NFS BACKUP 1=on, 0=off^M

^M

ENABLE_NON_PERSISTENT_NFS=0^M

^M

# umount NFS datastore after backup is complete 1=yes, 0=no^M

UNMOUNT_NFS=0^M

^M

# IP Address of NFS Server^M

NFS_SERVER=172.30.0.195^M

^M

Was kann ich dagegen machen?

Danke für deine Hilfe!

Hast du mir vielleicht auch noch einen Tipp warum meine 4GB Ram unter ESXi nur mit 3,2 GB (wie bei 32bit) angezeigt werden?

Gruß Joni

**s.kranz** · 16-02-2010, 04:20 PM

Hallo Joni,
sehr gut erkannt das Problem mit dem ^M ... Wird die Datei einmal mit Windows editiert, dann kommen diese ^M (Zeilenumbruch) hinein. Normalerweise gibt es unter Linux einen Befeht, um die Zeichen einfach zu entfernen, der fehlt aber beim ESXi ...

Zwei Möglichkeiten:
1. Die Datei nie unter Windows editieren, dann kommen die Zeichen da auch nicht hin. Also alle Änderungen mit dem vi durchführen (ich weiss, ist nicht einfach), sicherste Möglichkeit
2. Die Datei mit den ^M auf dem ESXi bearbeiten, dann:
a) cp ghettoVCB.sh ghettoVCB.sh.sicher
b) sed 's/'"$(printf '\015')"'$//g' ghettoVCB.sh > zzz.temp
c) mit vi zzz.temp kontrollieren ob die ^M weg sind
d) mv zzz.temp ghettoVCB.sh
e) chmod 750 ghettoVCB.sh
Wenn's nicht geklappt hat, dann die sicher-Datei nutzen.

Das hinter dem sed muss exakt so geschrieben werden.

Dann sollte es klappen ...

Gruß
Stephan

joni2000de · (Dieser Beitrag wurde zuletzt bearbeitet: 16-02-2010, 08:02 PM von joni2000de.)

Hallo Stephan,

das Script lässt sich jetzt ausführen. Doch ich erhalte folgende Fehlermeldung:

Error: failed to extract VM_ID for vws4!
edit: gefunden VWS4 Groß-/Kleinschreibung ist relevant.

:-(

Gruß Joni

joni2000de · (Dieser Beitrag wurde zuletzt bearbeitet: 17-02-2010, 03:38 PM von joni2000de.)

Hallo Stephan,
ich habe es soweit hinbekomen. Backup funktioniert derzeit testhalber stündlich inkl. Logfile.
Danke für deine Hilfe!

Ich würde jetzt noch gerne nach erfolgter Sicherung (von datastore1 auf datastore2) die gesicherten Files und das Logfile noch wegsichern. Ich bin da schon den ganzen Abend damit beschäftigt zu probieren und zu lesen. Direkt auf eine Windowsfreigabe klappt mit ESXi meines Wissens nicht. NFS mit einem NAS von Iomega habe ich noch nicht einzurichten gebrachte. Bei FTP habe ich hauptsächlich umfangreiche Scripte für Webserver gefunden.
edit: NFS mit NAS funktioniert zwischenzeitlich :-)

Hast du mir da vielleicht einen Tipp wie ich das am einfachsten einrichten könnte?

Noch eine Frage.

Das Script sichert die laufenden Maschinen. Wenn eine Maschine ausgeschalten ist wird das Script mit einem Fehler abgebrochen. Gibt es da auch eine Möglichkeit eine ausgeschaltene Maschine mit zu sichern und diese anschließend ausgeschalten zu lassen (sollte ja eigentlich die einfachere Aufgabenstellung sein)?

Gruß Joni

**s.kranz** · 17-02-2010, 04:45 PM

Hallo Joni,

es geht ja voran, sehr gut.

Also eigentlich sichert das Skript auch heruntergefahrene VMs. Wie lautet denn die Fehlermeldung? Eigentlich kann das Skript die VMs herunterfahren, SnapShot erstellen und dann clonen (und wieder die VM starten). Oder hat die VM einen SnapShot, dann geht es auch nicht. Kommt aber dann genau diese Fehlermeldung.

Gruß Stephan

joni2000de · 17-02-2010, 07:18 PM

Hallo Stephan,

ich werde das mal beobachten. Es kann auch sein, dass dies nur eine Info im Fenster "kürzlich bearbeitete Aufgaben" war und sich dies gar nicht auf das Backup ausgewirkt hat. Im Logfile steht auf jeden Fall nichts besonderes drin.

Ich melde mich morgen dann wieder.

Hast du vielleicht einen Link für mich wo ich nachlesen kann wie ich auf einem w2k3 Server eine NFS Freigabe einrichten muss, damit ich mit ESXi darauf zugreifen kann? Das hätte den Vorteil, dass ich nicht über das NAS (da hab ich es hin bekommen) gehen müsste, da ich die Backups auf dem w2k3 brauche um sie dem normalen Backupprozess zuzuführen.

Dank und Gruß Joni

**s.kranz** · 17-02-2010, 07:51 PM

Bei Windows 2003 R2:
http://technet.microsoft.com/de-de/libra...S.10).aspx

Bei Windows 2003 ohne R2:
Das muss erstmal Windows Services for Unix installiert werden, gibt es unter http://www.microsoft.com/downloads/detai...layLang=en

Doku unter http://technet.microsoft.com/de-de/inter...80242.aspx

Ist eigentlich ganz einfach, nur die Administration ist manchmal etwas seltsam.

Gruß
Stephan